java - 多层神经网络在 0.1 学习率下仅仅 10 个时期后收敛到无穷大

Question

所以我正在尝试设计一个多层神经网络，其中包含 3 个输入神经元、3 个隐藏神经元和 1 个输出神经元。

我计划让它学习 3 位异或模式。 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

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

忽略 D

这是代码，它以 0.1 的学习率在 10 个 epoch 后收敛，误差值降至无穷大:|

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

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

其次，你应该在相反的方向改变权重(你应该从权重中减去误差)。你收敛到无穷大的主要原因是这个。因为，你的权重越大，你的错误就越大。通过将误差添加到权重，您正在创建一个链式 react ，导致权重(和误差)收敛到无穷大。

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

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