matlab处理手写识别问题

function bpback1(ny,eta,mini_size,epoch)
%ny:隐藏层为1层，神经元数目为ny;eta:学习速率;mini_size:最小采样;eopch：迭代次数
%该函数为梯度下降+反向传播
%images
[numimages,images]=bpimages(‘train-images.idx3-ubyte‘);
[n_test,test_data_x]=bpimages(‘t10k-images.idx3-ubyte‘);
%labels
[numlabels,labels]=bplabels(‘train-labels.idx1-ubyte‘);
[n_test,test_data_y]=bplabels(‘t10k-labels.idx1-ubyte‘);
%init w/b
%rand(‘state‘,sum(100*clock));
%ny=30;eta=0.01;mini_size=10;
w1=randn(ny,784);
b1=randn(ny,1);
w2=randn(10,ny);
b2=randn(10,1);
for epo=1:epoch
for nums=1:numimages/mini_size
    for num=(nums-1)*mini_size+1:nums*mini_size
        x=images(:,num);
        y=labels(:,num);
    net2=w1*x;               %input of net2                  
    for i=1:ny
    hidden(i)=1/(1+exp(-net2(i)-b1(i)));%output of net2               
    end   
    net3=w2*hidden‘;            %input of net3              
    for i=1:10
    o(i)=1/(1+exp(-net3(i)-b2(i)));%output of net3
    end
    
    %back
    for i=1:10
    delta3(i)=(y(i)-o(i))*o(i)*(1-o(i));%delta of net3                 
    end
    for i=1:ny
    delta2(i)=delta3*w2(:,i)*hidden(i)*(1-hidden(i));%delta of net2    
    end
    %updata w/b
    for i=1:10
        for j=1:ny
    w2(i,j)=w2(i,j)+eta*delta3(i)*hidden(j)/mini_size;          
        end
    end
    for i=1:ny
        for j=1:784
    w1(i,j)=w1(i,j)+eta*delta2(i)*x(j)/mini_size;              
        end
    end
    for i=1:10
    b2(i)=b2(i)+eta*delta3(i);     
    end
    for i=1:ny
    b1(i)=b1(i)+eta*delta2(i);    
    end
    end 
end
%calculate sum of error
%accuracy
sum0=0;
for i=1:1000
    x0=test_data_x(:,i);
    y0=test_data_y(:,i);
    a1=[];
    a2=[];
    s1=w1*x0;
    for j=1:ny
    a1(j)=1/(1+exp(-s1(j)-b1(j)));
    end
    s2=w2*a1‘;
    for j=1:10
    a2(j)=1/(1+exp(-s2(j)-b2(j)));
    end
    a2=a2‘;
    [m1,n1]=max(a2);
    [m2,n2]=max(y0);
    if n1==n2
        sum0=sum0+1;
    end
    %e=o‘-y;
    %sigma(num)=e‘*e;
    sigma(i)=sumsqr(a2-y0);   %代价为误差平方和
end
sigmas(epo)=sum(sigma)/(2*1000);
fprintf(‘epoch %d:%d/%d\n‘,epo,sum0,1000); 
end
plot(sigmas);
xlabel(‘epoch‘);
ylabel(‘cost on the training_data‘);
end

function bpback2(ny,eta,mini_size,epoch,numda)
%ny:隐藏层为1层，神经元数目为ny;eta:学习速率;mini_size:最小采样;eopch：迭代次数
%bpback的优化，包括L2规范化、交叉熵代价函数的引入---结果证明该优化非常赞！
%images
[numimages,images]=bpimages(‘train-images.idx3-ubyte‘);
[n_test,test_data_x]=bpimages(‘t10k-images.idx3-ubyte‘);
%labels
[numlabels,labels]=bplabels(‘train-labels.idx1-ubyte‘);
[n_test,test_data_y]=bplabels(‘t10k-labels.idx1-ubyte‘);
%init w/b
%ny=30;eta=0.05;mini_size=10;epoch=10;numda=0.1;
rand(‘state‘,sum(100*clock));
w1=randn(ny,784)/sqrt(784);
b1=randn(ny,1);
w2=randn(10,ny)/sqrt(ny);
b2=randn(10,1);
for epo=1:epoch
for nums=1:numimages/mini_size
    for num=(nums-1)*mini_size+1:nums*mini_size
        x=images(:,num);
        y=labels(:,num);
    net2=w1*x;               %input of net2                  
    hidden=1./(1+exp(-net2-b1));%output of net2               
    net3=w2*hidden;            %input of net3               
    o=1./(1+exp(-net3-b2));%output of net3
    %back
    delta3=(y-o);%delta of net3   由于交叉熵代价函数的引入，偏导被消去
    delta2=w2‘*delta3.*(hidden.*(1-hidden));%delta of net2    
    %updata w/b
    w2=w2*(1-eta*numda/numimages)+eta*delta3*hidden‘/mini_size;     %L2规范化      
    w1=w1*(1-eta*numda/numimages)+eta*delta2*x‘/mini_size;               
    b2=b2+eta*delta3/mini_size;    
    b1=b1+eta*delta2/mini_size;    
    end 
end
%calculate sum of error
%accuracy
sum0=0;
for i=1:1000
    x0=test_data_x(:,i);
    y0=test_data_y(:,i);
    a1=[];
    a2=[];
    a1=1./(1+exp(-w1*x0-b1));
    a2=1./(1+exp(-w2*a1-b2));
    [m1,n1]=max(a2);
    [m2,n2]=max(y0);
    if n1==n2
        sum0=sum0+1;
    end
    %e=o‘-y;
    %sigma(num)=e‘*e;
    sigma(i)=m2*log(m1)+(1-m2)*log(1-m1);   %计算代价cost
end
sigmas(epo)=-sum(sigma)/1000;       %cost求和
fprintf(‘epoch %d:%d/%d\n‘,epo,sum0,1000); 
end
plot(sigmas);
xlabel(‘epoch‘);
ylabel(‘cost on the training_data‘);
end