XOR Java神经网络

尝试在java中使用XOR神经网络，但该网络总是预测它训练的最终输出

这是我的密码

for( int i = 0; i < 4; i++ ) { //Forward pass
        diff = 1;
        while( diff > 0.01 ) {
        SumError = 0;
        Y1 = ( InputOne[i] * Weight[0] ) + ( InputTwo[i] * Weight[1] ) + Weight[6];
        Y1 = 1 / ( 1 + Math.exp( -Y1 ) );
        Node1[i] = Y1;

        Y2 = ( InputOne[i] * Weight[2] ) + ( InputTwo[i] * Weight[3] ) + Weight[7];
        Y2 = 1 / ( 1 + Math.exp( -Y2 ) );
        Node2[i] = Y2;

        Y3 = ( Y1 * Weight[4] ) + ( Y2 * Weight[5] ) + Weight[8];
        Y3 = 1 / ( 1 + Math.exp( -Y3 ) );
        Node3[i] = Y3;

        diff = Math.abs( Result[i] - Y3 );

        System.out.println( i + " " + Result[i] + " " + Y3 + " " + diff );

        //Error Signals
        Delta3[i] = Y3 * ( 1 - Y3 ) * ( Result[i] - Y3 );
        Delta2[i] = Node2[i] * ( 1 - Node2[i] ) * ( Delta3[i] * Weight[5] );
        Delta1[i] = Node1[i] * ( 1 - Node1[i] ) * ( Delta3[i] * Weight[4] );

        //Update Weights
        Weight[0] = Weight[0] + ( ( WeightChange[0] * alpha ) + ( eta * Delta2[i] * InputOne[i] ) );
        Weight[2] = Weight[2] + ( ( WeightChange[2] * alpha ) + ( eta * Delta2[i] * InputTwo[i] ) );

        Weight[1] = Weight[1] + ( ( WeightChange[1] * alpha ) + ( eta * Delta1[i] * InputOne[i] ) );
        Weight[3] = Weight[3] + ( ( WeightChange[3] * alpha ) + ( eta * Delta1[i] * InputTwo[i] ) );

        Weight[4] = Weight[4] + ( ( WeightChange[4] * alpha ) + ( eta * Delta3[i] * Y1 ) );
        Weight[5] = Weight[5] + ( ( WeightChange[5] * alpha ) + ( eta * Delta3[i] * Y2 ) );

        Weight[6] = Weight[6] + ( ( WeightChange[6] * alpha ) + ( eta * Delta1[i] ) );
        Weight[7] = Weight[7] + ( ( WeightChange[7] * alpha ) + ( eta * Delta2[i] ) );
        Weight[8] = Weight[8] + ( ( WeightChange[8] * alpha ) + ( eta * Delta3[i] ) );

        for( int k = 0; k < 9; k++ ) {
            WeightChange[k] = OldWeight[k] - Weight[k];
            OldWeight[k] = Weight[k];
        }

        //Global Error
    for( int j = 0; j < 4; j++ ) {
        Y1 = ( InputOne[j] * Weight[0] ) + ( InputTwo[j] * Weight[1] ) + Weight[6];
        Y1 = 1 / ( 1 + Math.exp( -Y1 ) );

        Y2 = ( InputOne[j] * Weight[2] ) + ( InputTwo[j] * Weight[3] ) + Weight[7];
        Y2 = 1 / ( 1 + Math.exp( -Y2 ) );

        Y3 = ( Y1 * Weight[4] ) + ( Y2 * Weight[5] ) + Weight[8];
        Y3 = 1 / ( 1 + Math.exp( -Y3 ) );

        //System.out.println( Y3 + " " + Math.abs( Result[j] - Y3 ) );

        SumError = SumError + Math.pow( ( Result[j] - Y3 ) , 2 );
    }
        SumError = SumError * 0.5;
    }
    Count = Count + 1;  
        }

for（int i=0；i<4；i++）{//向前传递
差异=1；
而（差值>0.01）{
sumeror=0；
Y1=（输入按钮[i]*重量[0]）+（输入WO[i]*重量[1]）+重量[6]；
Y1=1/（1+数学表达式（-Y1））；
节点1[i]=Y1；
Y2=（输入按钮[i]*重量[2]）+（输入WO[i]*重量[3]）+重量[7]；
Y2=1/（1+数学表达式（-Y2））；
节点2[i]=Y2；
Y3=（Y1*重量[4]）+（Y2*重量[5]）+重量[8]；
Y3=1/（1+数学经验（-Y3））；
节点3[i]=Y3；
diff=Math.abs（结果[i]-Y3）；
System.out.println（i+“”+结果[i]+“”+Y3+“”+diff）；
//错误信号
Delta3[i]=Y3*（1-Y3）*（结果[i]-Y3）；
Delta2[i]=节点2[i]*（1-节点2[i]）*（Delta3[i]*权重[5]）；
Delta1[i]=Node1[i]*（1-Node1[i]）*（Delta3[i]*权重[4]）；
//更新权重
权重[0]=权重[0]+（（权重变化[0]*alpha）+（eta*Delta2[i]*InputOne[i]）；
权重[2]=权重[2]+（（权重变化[2]*alpha）+（eta*Delta2[i]*inputwo[i]）；
重量[1]=重量[1]+（（重量变化[1]*alpha）+（eta*Delta1[i]*InputOne[i]）；
权重[3]=权重[3]+（（权重变化[3]*alpha）+（eta*Delta1[i]*inputwo[i]）；
权重[4]=权重[4]+（（权重变化[4]*alpha）+（eta*Delta3[i]*Y1））；
权重[5]=权重[5]+（（权重变化[5]*alpha）+（eta*Delta3[i]*Y2））；
权重[6]=权重[6]+（（权重变化[6]*alpha）+（eta*Delta1[i]）；
权重[7]=权重[7]+（（权重变化[7]*alpha）+（eta*Delta2[i]）；
权重[8]=权重[8]+（（权重变化[8]*alpha）+（eta*Delta3[i]）；
对于（int k=0；k<9；k++）{
权重变化[k]=旧权重[k]-权重[k]；
旧重量[k]=重量[k]；
}
//全局误差
对于（int j=0；j<4；j++）{
Y1=（输入按钮[j]*重量[0]）+（输入WO[j]*重量[1]）+重量[6]；
Y1=1/（1+数学表达式（-Y1））；
Y2=（输入按钮[j]*重量[2]）+（输入WO[j]*重量[3]）+重量[7]；
Y2=1/（1+数学表达式（-Y2））；
Y3=（Y1*重量[4]）+（Y2*重量[5]）+重量[8]；
Y3=1/（1+数学经验（-Y3））；
//System.out.println（Y3+“”+Math.abs（结果[j]-Y3））；
sumerro=sumerro+Math.pow（（结果[j]-Y3），2）；
}
SumError=SumError*0.5；
}
计数=计数+1；
}

其中，

InputOne

、

inputwo

和

Result

是异或的真值表条目，权重是随机分配的，

weightschange

是动量

然后我再次输入真值表，每个输出都或多或少地与它训练的最后一个输入相同

有人有什么想法吗？

你应该针对案例1（一次）、案例2（一次）、案例3（一次）、案例4（一次）进行培训，然后再重复一遍，直到它学会所有四种方法。没有一个病例。每个案例进行一次迭代。你需要让它学会塑料。对于你的教学计划，当你教授案例2时，它会忘记案例1。您需要在一个公共while循环中重复输入所有案例，直到总错误减少到一个下限

---

当你让它只学一种情况时，它会学得很好，但会忘记其他情况。因此，您需要一个接一个地输入，并将一组案例的总误差（可能是误差平方和）设置为小于公差。

好的，我明白了，谢谢。当你说“它忘记了案例1”时，这是否意味着重新开始？重设重量？