多层感知器总是选择它被训练指定的最后一个类。反向传播

Question

我正在尝试编写一个将输入分类为三个对象的 MLP。 我有一个代表每个对象的数字。

1-10 : Banana
11-20 : Apple
21:30 : Carrot

MLP 中只有两层：一层隐藏层（2 个单元）和一层输出层（3 个单元）。
每个单元有：

• inputs[]（传递给此单元的输入）
• 权重[]
• 三角洲
• sum（输入权重的总和）
• 输出（激活总和）

每个单元也有一个激活函数：

double activate(double[] inputs) {
        this.inputs = inputs;
        sum = 0;

        for (int i = 0; i < inputs.length; i++)
            sum += weights[i] * inputs[i];

        output = 1.0 / (1.0 + (Math.exp(-sum))); // activation

        return output;
    }

还有一个校正权重的函数：

void correctWeights(double momentum, double learningRate) {
        for (int i = 0; i < weights.length; i++) {
            weights[i] = weights[i] * momentum + learningRate * delta * (output * (1 - output)) * inputs[i];
        }
    }

其中(output * (1 - output)) 是导数。

为了训练网络，我有一个循环 N 次的函数，在循环中我生成相对于对象的输入，然后将其传播到网络并使用反向传播。

private void train() {
        for (int i = 0; i < 10000; i++) {
            int[] expectedOutput = new int[3];
            double[] inputs = {ThreadLocalRandom.current().nextInt(1, 30 + 1)};
            if (inputs[0] <= 10) {
                expectedOutput[0] = 1;
                expectedOutput[1] = 0;
                expectedOutput[2] = 0;
            }
            if (inputs[0] <= 20 && inputs[0] > 10) {
                expectedOutput[0] = 0;
                expectedOutput[1] = 1;
                expectedOutput[2] = 0;
            }
            if (inputs[0] <= 30 && inputs[0] > 20) {
                expectedOutput[0] = 0;
                expectedOutput[1] = 0;
                expectedOutput[2] = 1;
            }
            double[] outputs = propagate(inputs);
            backPropagate(expectedOutput, outputs);
        }
    }

传播功能只是通过整个网络并激活单元。

private double[] propagate(double[] inputs) {
        double[] hiddenOutputs = new double[hiddenLayer.length];
        for (int i = 0; i < hiddenLayer.length; i++)
            hiddenOutputs[i] = hiddenLayer[i].activate(inputs);

        double[] outputs = new double[outputLayer.length];
        for (int i = 0; i < outputs.length; i++)
            outputs[i] = outputLayer[i].activate(hiddenOutputs);

        return outputs;
    }

反向传播算法取自http://home.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html

private void backPropagate(int[] expectedOutput, double[] output) {
        for (int i = 0; i < outputLayer.length; i++) {
            outputLayer[i].setDelta(expectedOutput[i] - output[i]);
        }

        for (int i = 0; i < hiddenLayer.length; i++) {
            double delta = 0;
            for (int j = 0; j < outputLayer.length; j++) {
                delta += outputLayer[j].getDelta() * outputLayer[j].getWeight(i);
            }
            hiddenLayer[i].setDelta(delta);
        }

        for (int i = 0; i < hiddenLayer.length; i++)
            hiddenLayer[i].correctWeights(momentum, learningRate);

        for (int i = 0; i < outputLayer.length; i++)
            outputLayer[i].correctWeights(momentum, learningRate);
    }

它还具有训练后识别物体的功能

private void recognize(String number) {
        double[] inputs = {Double.parseDouble(number)};
        double[] outputs = propagate(inputs);
        System.out.println("Banana: " + outputs[0]);
        System.out.println("Apple: " + outputs[1]);
        System.out.println("Carrot: " + outputs[2]);
    }

所以问题是，当我将任何数字传递给 recognize 函数时，我得到的输出类似于：

Banana: 0.49984367018594233
Apple: 0.49984367018594233
Carrot: 0.5001563298140577

每次都选择胡萝卜（胡萝卜也是网络最后训练的对象）。因此，如果我输入 5，它将输出它是胡萝卜。如果我输入 15，它将输出它是胡萝卜。如果我在 train 函数中更改正在学习的对象的顺序并使香蕉成为最后学习的对象，那么网络将始终选择香蕉作为其答案。

我已经研究了几天了，但我找不到任何解决方案，请帮助我，我做错了什么？

Answer 1

我注意到您选择了一个介于 0-30 之间的随机数，然后为其确定了一个输出，但是您忘记了对输入进行规范化。如果输入在0-1 的范围内（取决于您使用的激活函数），则神经网络的功能最佳。

所以剩下要做的就是对这个输入进行规范化。这意味着，将输入平均转换为0 和1 之间的数字。

您的输入是一个数值，因此您所要做的就是选择一个最大值，除以所有值。在您的情况下，这可能是30，因为没有高于30 的输入。所以每个数字都被转换如下：

10 -> 10 / 30 -> 0.33
15 -> 15 / 30 -> 0.50
etc.

阅读更多关于标准化的信息here。