Matlab中的神经网络反向传播发生了什么

我是MATLAB的新手，我想用C验证在线反向传播（BP）代码。我需要测试代码在相同的网络设置下是否完全相同。网络设置为原始BP（用于异或问题）2个输入、2个隐藏节点和1个输出。使用的学习率设置为0.01，动量为0.95，而停止标准为0.01，性能度量为sse。epoch是1（因为我想检查从正向传播到反向传播的精确计算，以便验证网络设置是否与C中的设置完全相同） 这是我的密码：

   clear all;clc
   input =  [0 0; 0 1; 1 0; 1 1]';
   target = [0 1 1 0];   % p = [-1 -1 2 2; 0 5 0 5]; % t = [-1 -1 1 1];
   state0 =  1367;
   rand('state',state0)
   net = newff(input,target,2,{},'traingd');
   net.divideFcn = '';

   %set max epoh, goal, learning rate, show stp
   net.trainParam.epochs        =1;
   net.trainParam.goal        = 0.01;
   net.performFcn ='sse';
   net.trainParam.lr          = 0.01;
   net.adaptFcn=' ';

   net.trainParam.show        = 100;
   net.trainparam.mc          = 0.95;
   net.layers{1}.transferFcn = 'logsig';
   net.layers{2}.transferFcn = 'logsig';

   wih     = net.IW{1,1};
   wihb= net.b{1,1};
   who   = net.LW{2,1};
   whob = net.b{2,1};

   %Train
   net = train(net,input,target); %adapt
   y= sim(net,input);
   e=target-y;
   perf = sse(e)

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

运行之后，我发现y（1）是0.818483286935909 它与手动计数不同，手动计数为0.609299823823181 （我通过计算重新检查==>

for i=1:size(input,2)
hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );end  )

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

我的问题是: 1） 原始MATLAB是否使用traingd？ 2） 到底是什么 净=列车（净、输入、目标）； y=sim（网络，输入）；如果使用train和sim卡，手动计算结果为0.609299823823181，而不是0.818483286935909，则执行此操作

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

3） 与上面的matlab代码相比，我用C编写的粗略正向传播有什么不同

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

请，请帮帮我。

1）我相信Matlabs“训练”命令使用批量学习，而不是在线学习。也许你应该研究一下Matlab中用于在线培训的“自适应”函数，但不知道它是否有用。您是在问train（）和traingd（）是否实际上是相同的方法，还是在问train是否也使用梯度下降法

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

2） Matlab help说：“通常，一个训练阶段被定义为所有输入向量到网络的单个表示。然后根据所有这些表示的结果更新网络。”

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

我猜这意味着train将反向传播并“训练”网络一次，然后你根据这个训练过的网络模拟一个答案

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

3） 这里列出的C代码是程序中的所有代码吗？如果是这样的话，我想区别在于Matlab更新权重一次，然后进行前馈，而您的C代码似乎只进行前馈？？还是我遗漏了什么/你遗漏了什么

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

---

希望我正确理解了您的所有问题，它们有时有点不清楚，如果我有什么错误，请发表意见。

谢谢Niclas，我看到了自适应功能，我猜newff功能初始化不同的权重（在newff初始化和reinit激活功能期间）

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

2） 我也相信培训应该使用批量培训。但当我检查输出时：

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

3） C代码如下所示：

 for i=1:size(input,2)
     hidden(1) = logsig( wih (1)*input(1) + wih(2)*input(2) + wihb(1) );
     hidden(2) = logsig( wih (3)*input(1) + wih(4)*input(2) + wihb(2) );
     out(i) = logsig( hidden(1)*who(1) + hidden(2)*who(2) + whob(1) );
 end  

void forwardPropagate(double *Input)
{  
  int i,j,k;
  double sumIH=0.0,sumHO=0.0;

for(j=0; j< numHid; j++)
{ 
    for(i=0; i<numInput; i++) //numInput+1
    {     //   
        sumIH+=Input[i] * wtIH[j][i]; 
    }
    sumIH+=(1.0 * wtIH[j][numInput]); 
    Hidden[j]=sigmoid(sumIH);          
}     


    for(k = 0 ; k< numOutput ; k++ ) 
{ 
    for(j =0 ; j <numHid ; j++ ) //numHid+1
    { 
        sumHO+=Hidden[j] * wtHO[k][j];          
    }
    sumHO+=(1.0 * wtHO[k][numHid]);   
    Output[k]=sigmoid(sumHO);
}
}


void backPropagate (double *target)
{  
  int j,k;  
  double sumOutErr, desired[numOutput];

  for(k = 0 ; k<numOutput ; k++ ) 
  {   
     desired[k]=target[k];
         error[k]=desired[k]-Output[k];      
  deltaOutput[k]=beta *(Output[k] * (1 - Output[k]))*(error[k]);
   }

 for( j =0 ; j <numHid; j++ ) 
 {    
  sumOutErr= 0.0 ;     
  for( k = 0 ; k < numOutput ; k++ )    
  {
      sumOutErr+= wtHO[k][j] * deltaOutput[k] ;         
  } 
  deltaHidden[j] = beta* sumOutErr * Hidden[j] * (1.0 - Hidden[j]); 
   }
 }     


 void weight_changes(double *test_pat){

int h,i,j,k;

for( k = 0 ; k < numOutput ; k ++ ) {    // update weights WeightHO           

    for( j = 0 ; j < numHid ; j++ ) { //asal numHid+1;    


        delta_wtHO[k][j]= alpha * Hidden[j]*deltaOutput[k] +   
                        M*delta_wtHO[k][j];
        wtHO[k][j] += delta_wtHO[k][j];

    }//bias
    delta_wtHO[k][numHid]= alpha * 1.0 *deltaOutput[k] + M*delta_wtHO[k]'
            [numHid];   
    wtHO[k][numHid] += delta_wtHO[k][numHid];
}

for( h = 0 ; h < numHid ; h++ ) {     // update weights WeightIH                
    for( i = 0 ; i < numInput ; i++ ) { //asal numInput+1

        delta_wtIH[h][i] =alpha * test_pat[i] *              
                        deltaHidden[h]+M*delta_wtIH[h][i]; 
        wtIH[h][i] += delta_wtIH[h][i] ;

    }   //bias
    delta_wtIH[h][numInput] =alpha * 1.0 * deltaHidden[h]+M*delta_wtIH[h]
                  [numInput];   
    wtIH[h][numInput] += delta_wtIH[h][numInput] ;
 }
    }

void前向传播（双*输入）
{  
int i，j，k；
双sumIH=0.0，sumHO=0.0；
对于（j=0；j对于（i=0；ithank Niclas，我看到了自适应函数，我猜newff函数初始化不同的权重（在newff init和reinit激活函数期间）2），我也相信使用批训练的traingd。但是当我检查i=1:size（input，2）hidden（1）=logsig（wih（1）*input（1）+wih（2）*input（2）+wihb（1））；hidden（2）=logsig（wih（3）*输入（1）+wih（4）*输入（2）+wihb（2））；输出（i）=logsig（隐藏（1）*谁（1）+隐藏（2）*谁（2）+谁（1））；结束）3）C代码如下