Question

所以我试图设计一个具有3个输入神经元3个隐藏神经元和1个输出神经元的多层神经网络。

我打算让它学习3位xor模式。 b1 xor b2 xor b3种表。现在我想把它教给下表。

0d,0d,0d    =>0d
0d,0d,1d    =>1d    
0d,1d,0d    =>1d
0d,1d,1d    =>0d
1d,1d,0d    =>0d
1d,1d,1d    =>1d

enter image description here

hidden []是隐藏层和输出层之间的权重 input []是输入和隐藏层之间的权重。

忽略D's

这是代码，它在仅有10个时代后以0.1学习率收敛，误差值降至无穷大：|

class neuron{
    double hidden[] = {1d,1d,1d};
    double input[][] = { {1d,1d,1d},{1d,1d,1d},{1d,1d,1d}};
    double learning = 0.1;
    double bias = 1d;

    public double[] react(double a,double b,double c){
        double h1 = a*input[0][0] + b*input[0][1] + c*input[0][2];
        double h2 = a*input[1][0] + b*input[1][1] + c*input[1][2];
        double h3 = a*input[2][0] + b*input[2][1] + c*input[2][2];
        //System.out.println(input[0][0]);
        double total[] = new double[4];
        total[0] = h1*hidden[0] + h2*hidden[1] + h3*hidden[2] + bias;
        total[1] = h1; total[2] = h2; total[3] = h3;
        return total;
    }

    public void learn(double a,double b, double c, double ideal){
        double actual[] = react(a,b,c);

        double error = ideal - actual[0];
        System.out.println(error);
        error *= learning;

        for( int i = 0; i < 3; i++ )
            hidden[i] += error * actual[i+1];
        bias += error;
        for( int i = 0; i < 3; i++ ){
            input[i][0] +=  error * actual[i+1] * a;
            input[i][1] +=  error * actual[i+1] * b;
            input[i][2] +=  error * actual[i+1] * c;
        }

        }
    }



public class multilayer{

        public static void main(String argz[]){
        neuron a = new neuron();
        for( int i = 0; i < 20; i++){
            a.learn(0d,0d,0d,0d);
            a.learn(0d,0d,1d,0d);   
            a.learn(0d,1d,0d,0d);
            a.learn(0d,1d,1d,0d);
            a.learn(1d,1d,0d,0d);
            a.learn(1d,1d,1d,1d);

        }
        System.out.println(a.react(0d,0d,0d)[0] >=0.5 ? 1 : 0);
        System.out.println(a.react(0d,0d,1d)[0]>=0.5 ? 1 : 0);
        System.out.println(a.react(0d,1d,0d)[0]>=0.5 ? 1 : 0);
        System.out.println(a.react(1d,1d,0d)[0]>=0.5 ? 1 : 0);
        System.out.println(a.react(0d,1d,1d)[0]>=0.5 ? 1 : 0);
        System.out.println(a.react(1d,1d,1d)[0]>=0.5 ? 1 : 0);
        }
}

我击落了一个隐藏的神经元，它仍然会收敛到无限所有的重量！

Answer 1

首先，您还应为每个隐藏单元添加偏置输入。人工神经网络中的每个非输入单元都应该有偏置输入，这将有助于单元更快地收敛。

其次，你应该改变相反方向的权重（你应该从权重中减去误差）。你融入无限的主要原因是这个。因为，你的权重越大，你的错误就越大。通过将误差添加到重量中，您将产生连锁反应，从而导致权重（和误差）收敛到无穷大。

第三，你的学习算法是完全错误的:)特别是你计算关于错误及其输入的输入权重的部分。

在多层神经网络中，您应该使用错误反向传播算法（EBP）。该算法根据最终错误中的份额改变每个权重。为了找到变化率，它使用输出误差的导数。有关EBP检查this问题的详细信息。

多层神经网络在不到10个时期后以0.1学习率收敛到无穷大

1 个答案: