Question

我试图将here的神经网络重写为javascript。我的javascript代码看起来像这样。

function NeuralFactor(weight) {
    var self = this;
    this.weight = weight;
    this.delta =  0;
}

function Sigmoid(value) {
    return 1 / (1 + Math.exp(-value));
}

function Neuron(isInput) {
    var self = this;
    this.pulse = function() {
        self.output = 0;
        self.input.forEach(function(item) {
            self.output += item.signal.output * item.factor.weight;
        });

        self.output += self.bias.weight;
        self.output = Sigmoid(self.output);
    };

    this.bias = new NeuralFactor(isInput ? 0 : Math.random());
    this.error = 0;
    this.input = [];
    this.output = 0;

    this.findInput = function(signal) {
        var input = self.input.filter(function(input) {
            return signal == input.signal;
        })[0];
        return input;
    };
}

function NeuralLayer() {
    var self = this;
    this.pulse = function() {
        self.neurons.forEach(function(neuron) {
            neuron.pulse();
        });
    };
    this.neurons = [];
    this.train = function(learningRate) {
        self.neurons.forEach(function(neuron) {
            neuron.bias.weight += neuron.bias.delta * learningRate;
            neuron.bias.delta = 0;
            neuron.input.forEach(function(input) {
                input.factor.weight += input.factor.delta * learningRate;
                input.factor.delta = 0;
            })
        })
    }
}

function NeuralNet(inputCount, hiddenCount, outputCount) {
    var self = this;
    this.inputLayer = new NeuralLayer();
    this.hiddenLayer = new NeuralLayer();
    this.outputLayer = new NeuralLayer();
    this.learningRate = 0.5;

    for(var i = 0; i < inputCount; i++)
        self.inputLayer.neurons.push(new Neuron(true));

    for(var i = 0; i < hiddenCount; i++)
        self.hiddenLayer.neurons.push(new Neuron());

    for(var i = 0; i < outputCount; i++)
        self.outputLayer.neurons.push(new Neuron());

    for (var i = 0; i < hiddenCount; i++)
        for (var j = 0; j < inputCount; j++)
            self.hiddenLayer.neurons[i].input.push({
                signal: self.inputLayer.neurons[j],
                factor: new NeuralFactor(Math.random())
            });

    for (var i = 0; i < outputCount; i++)
        for (var j = 0; j < hiddenCount; j++)
            self.outputLayer.neurons[i].input.push({
                signal: self.hiddenLayer.neurons[j],
                factor: new NeuralFactor(Math.random())
            });

    this.pulse = function() {
        self.hiddenLayer.pulse();
        self.outputLayer.pulse();
    };

    this.backPropagation = function(desiredResults) {
        for(var i = 0; i < self.outputLayer.neurons.length; i++) {
            var outputNeuron = self.outputLayer.neurons[i];
            var output = outputNeuron.output;
            outputNeuron.error = (desiredResults[i] - output) * output * (1.0 - output);
        }
        for(var i = 0; i < self.hiddenLayer.neurons.length; i++) {
            var hiddenNeuron = self.hiddenLayer.neurons[i];
            var error = 0;
            for(var j = 0; j < self.outputLayer.neurons.length; j++) {
                var outputNeuron = self.outputLayer.neurons[j];
                error += outputNeuron.error * outputNeuron.findInput(hiddenNeuron).factor.weight * hiddenNeuron.output * (1.0 - hiddenNeuron.output);
            }
            hiddenNeuron.error = error;
        }
        for(var j = 0; j < self.outputLayer.neurons.length; j++) {
            var outputNeuron = self.outputLayer.neurons[j];
            for(var i = 0; i < self.hiddenLayer.neurons.length; i++) {
                var hiddenNeuron = self.hiddenLayer.neurons[i];
                outputNeuron.findInput(hiddenNeuron).factor.delta += outputNeuron.error * hiddenNeuron.output;
            }
            outputNeuron.bias.delta += outputNeuron.error * outputNeuron.bias.weight;
        }
        for(var j = 0; j < self.hiddenLayer.neurons.length; j++) {
            var hiddenNeuron = self.hiddenLayer.neurons[j];
            for(var i = 0; i < self.inputLayer.neurons.length; i++) {
                var inputNeuron = self.inputLayer.neurons[i];
                hiddenNeuron.findInput(inputNeuron).factor.delta += hiddenNeuron.error * inputNeuron.output;
            }
            hiddenNeuron.bias.delta += hiddenNeuron.error * hiddenNeuron.bias.weight;
        }
    };
    this.train = function(input, desiredResults) {
        for(var i = 0; i < self.inputLayer.neurons.length; i++) {
            var neuron = self.inputLayer.neurons[i];
            neuron.output = input[i];
        }

        self.pulse();
        self.backPropagation(desiredResults);

        self.hiddenLayer.train(self.learningRate);
        self.outputLayer.train(self.learningRate);
    };

}

现在我正在尝试学习如何解决XOR问题。我是这样教的：

var net = new NeuralNet(2,2,1);

var testInputs = [[0,0], [0,1], [1,0], [1,1]];
var testOutputs = [[1],[0],[0],[1]];

for (var i = 0; i < 1000; i++)
    for(var j = 0; j < 4; j++)
        net.train(testInputs[j], testOutputs[j]);

function UseNet(a, b) {
    net.inputLayer.neurons[0].output = a;
    net.inputLayer.neurons[1].output = b;
    net.pulse();

    return net.outputLayer.neurons[0].output;
}

问题在于，无论我使用什么参数，我得到的所有结果都接近0.5并且非常随机。例如：

UseNet(0,0) => 0.5107701166677714
UseNet(0,1) => 0.4801498747476413
UseNet(1,0) => 0.5142463167153447
UseNet(1,1) => 0.4881829364416052

我的代码有什么问题？

Answer 1

该系统使用模糊逻辑。正如文章中所说，不要使用整数而是使用＆＃34; close＆＃34;文章建议的实数 - 试试

UseNet(0.1,0.1) => 
UseNet(0.1,0.9) => 
UseNet(0.9,0.1) => 
UseNet(0.9,0.9) =>

对于结果，任何高于0.5的值都是1且低于0

Answer 2

这个网络足以解决XOR问题，我看不出任何明显的错误，所以我怀疑它会陷入局部最低限度。

尝试通过训练集10,000次而不是1000次;这使它有更好的机会突破任何最小值和收敛。您还可以通过增加隐藏神经元的数量，调整η（学习速率）或增加动量来增加收敛。要实现后者，请尝试将此作为您的培训功能：

this.train = function(learningRate) {
    var momentum = 0 /* Some value, probably fairly small. */;
    self.neurons.forEach(function(neuron) {
        neuron.bias.weight += neuron.bias.delta * learningRate;
        neuron.bias.delta = 0;
        neuron.input.forEach(function(input) {
            input.factor.weight += (input.factor.delta * learningRate) + (input.factor.weight * momentum);
            input.factor.delta = 0;
        })
    })
}

我已经取得了很好的成绩，将学习率提高到1.5（相当高），动力达到0.000001（非常小）。

（顺便说一句，您是否尝试使用一些不同的种子运行.NET实现？它可以花费很长时间来收敛！）

Answer 3

嗯，

尝试代替：

var testInputs = [[0,0], [0,1], [1,0], [1,1]];
var testOutputs = [[1],[0],[0],[1]];

此：

var testInputs = [[0.05,0.05], [0.05,0.95], [0.95,0.05], [0.95,0.95]];
var testOutputs = [[1],[0],[0],[1]];

或

var testInputs = [[0,0], [0,1], [1,0], [1,1]];
var testOutputs = [[0.95],[0.05],[0.05],[0.95]];

Javascript中的神经网络无法正常学习

3 个答案: