简单的神经网络无法学习XOR。

Question

我正在学习神经网络，并编写了一个简单的反向传播神经网络，它使用Sigmoid激活函数、随机权重初始化和学习/梯度动量。当配置为2个输入、2个隐藏节点和1个输出时，它无法学习XOR和AND，但是可以正确地学习OR。

我不知道我做错了什么，希望能得到帮助。谢谢！

编辑：如上所述，我测试了2个隐藏节点，但下面的代码显示了3个节点的配置。在使用3个隐藏节点运行测试后，我只是忘记将其改回2个节点。

network.rb:

module Neural

class Network

    attr_accessor :num_inputs, :num_hidden_nodes, :num_output_nodes, :input_weights, :hidden_weights, :hidden_nodes, 
                    :output_nodes, :inputs, :output_error_gradients, :hidden_error_gradients,
                    :previous_input_weight_deltas, :previous_hidden_weight_deltas

    def initialize(config)
        initialize_input(config)
        initialize_nodes(config)
        initialize_weights
    end

    def initialize_input(config)
        self.num_inputs = config[:inputs]
        self.inputs = Array.new(num_inputs+1)
        self.inputs[-1] = -1
    end

    def initialize_nodes(config)
        self.num_hidden_nodes = config[:hidden_nodes]
        self.num_output_nodes = config[:output_nodes]
        # treat threshold as an additional input/hidden node with no incoming inputs and a value of -1
        self.output_nodes = Array.new(num_output_nodes)
        self.hidden_nodes = Array.new(num_hidden_nodes+1)
        self.hidden_nodes[-1] = -1
    end

    def initialize_weights
        # treat threshold as an additional input/hidden node with no incoming inputs and a value of -1
        self.input_weights = Array.new(hidden_nodes.size){Array.new(num_inputs+1)}
        self.hidden_weights = Array.new(output_nodes.size){Array.new(num_hidden_nodes+1)}
        set_random_weights(input_weights)
        set_random_weights(hidden_weights)
        self.previous_input_weight_deltas = Array.new(hidden_nodes.size){Array.new(num_inputs+1){0}}
        self.previous_hidden_weight_deltas = Array.new(output_nodes.size){Array.new(num_hidden_nodes+1){0}}
    end

    def set_random_weights(weights)
        (0...weights.size).each do |i|
            (0...weights[i].size).each do |j|
                weights[i][j] = (rand(100) - 49).to_f / 100
            end
        end
    end

    def calculate_node_values(inputs)
        inputs.each_index do |i|
            self.inputs[i] = inputs[i]
        end

        set_node_values(self.inputs, input_weights, hidden_nodes)
        set_node_values(hidden_nodes, hidden_weights, output_nodes)
    end

    def set_node_values(values, weights, nodes)
        (0...weights.size).each do |i|
            nodes[i] = Network::sigmoid(values.zip(weights[i]).map{|v,w| v*w}.inject(:+))
        end
    end

    def predict(inputs)
        calculate_node_values(inputs)
        output_nodes.size == 1 ? output_nodes[0] : output_nodes
    end

    def train(inputs, desired_results, learning_rate, momentum_rate)
        calculate_node_values(inputs)
        backpropogate_weights(desired_results, learning_rate, momentum_rate)
    end

    def backpropogate_weights(desired_results, learning_rate, momentum_rate)
        output_error_gradients = calculate_output_error_gradients(desired_results)
        hidden_error_gradients = calculate_hidden_error_gradients(output_error_gradients)
        update_all_weights(inputs, desired_results, hidden_error_gradients, output_error_gradients, learning_rate, momentum_rate)
    end

    def self.sigmoid(x)
        1.0 / (1 + Math::E**-x)
    end

    def self.dsigmoid(x)
        sigmoid(x) * (1 - sigmoid(x))
    end

    def calculate_output_error_gradients(desired_results)
        desired_results.zip(output_nodes).map{|desired, result| (desired - result) * Network::dsigmoid(result)}
    end

    def reversed_hidden_weights
        # array[hidden node][weights to output nodes]
        reversed = Array.new(hidden_nodes.size){Array.new(output_nodes.size)}
        hidden_weights.each_index do |i|
            hidden_weights[i].each_index do |j|
                reversed[j][i] = hidden_weights[i][j];
            end
        end
        reversed

    end

    def calculate_hidden_error_gradients(output_error_gradients)
        reversed = reversed_hidden_weights
        hidden_nodes.each_with_index.map do |node, i|
            Network::dsigmoid(hidden_nodes[i]) * output_error_gradients.zip(reversed[i]).map{|error, weight| error*weight}.inject(:+)
        end
    end

    def update_all_weights(inputs, desired_results, hidden_error_gradients, output_error_gradients, learning_rate, momentum_rate)
        update_weights(hidden_nodes, inputs, input_weights, hidden_error_gradients, learning_rate, previous_input_weight_deltas, momentum_rate)
        update_weights(output_nodes, hidden_nodes, hidden_weights, output_error_gradients, learning_rate, previous_hidden_weight_deltas, momentum_rate)
    end

    def update_weights(nodes, values, weights, gradients, learning_rate, previous_deltas, momentum_rate)
        weights.each_index do |i|
            weights[i].each_index do |j|
                delta = learning_rate * gradients[i] * values[j]
                weights[i][j] += delta + momentum_rate * previous_deltas[i][j]
                previous_deltas[i][j] = delta
            end
        end


    end

end

end

test.rb:

#!/usr/bin/ruby

load "network.rb"

learning_rate = 0.3
momentum_rate = 0.2

nn = Neural::Network.new(:inputs => 2, :hidden_nodes => 3, :output_nodes => 1)
10000.times do |i|
    # XOR - doesn't work
    nn.train([0, 0], [0], learning_rate, momentum_rate)
    nn.train([1, 0], [1], learning_rate, momentum_rate)
    nn.train([0, 1], [1], learning_rate, momentum_rate)
    nn.train([1, 1], [0], learning_rate, momentum_rate)

    # AND - very rarely works
    # nn.train([0, 0], [0], learning_rate, momentum_rate)
    # nn.train([1, 0], [0], learning_rate, momentum_rate)
    # nn.train([0, 1], [0], learning_rate, momentum_rate)
    # nn.train([1, 1], [1], learning_rate, momentum_rate)

    # OR - works
    # nn.train([0, 0], [0], learning_rate, momentum_rate)
    # nn.train([1, 0], [1], learning_rate, momentum_rate)
    # nn.train([0, 1], [1], learning_rate, momentum_rate)
    # nn.train([1, 1], [1], learning_rate, momentum_rate)
end

puts "--- TESTING ---"
puts "[0, 0]"
puts "result "+nn.predict([0, 0]).to_s
puts
puts "[1, 0]"
puts "result "+nn.predict([1, 0]).to_s
puts
puts "[0, 1]"
puts "result "+nn.predict([0, 1]).to_s
puts
puts "[1, 1]"
puts "result "+nn.predict([1, 1]).to_s
puts

- growlyface

---

我会通过设置包含两个示例的初始权重和导数/错误的完整测试用例来开始调试，然后逐步进入代码。 - mota

你应该将代码简化成一个最小化的能够解释问题的代码。现在你所提供的代码相当于整个应用程序了。 - tadman

你的程序看起来可能正在做一些有趣的事情。但是每种编程语言都有自己的惯例，Ruby 的强大之处在于它的简洁性。你可以将这个问题带到 codereview.stackexchange.com 上进行讨论。 - Eric Walker

有人在SO上要求查看原始代码，因此我决定发布整个应用程序。然而，我同意，它很长，并且说实话，我对回复的数量感到惊讶。在发布之前，我通过了一个测试用例，并验证了反向传播每一步计算出的值与预期值相匹配。我将尝试使用其他测试用例，并阅读更多关于BP的内容，以确定是否误解了算法。 - growlyface

Answer 1

我的答案不是关于Ruby，而是关于神经网络的。首先，你需要了解如何在纸上编写输入和网络。如果实现二进制运算符，则你的空间将由XY平面上的四个点组成。在X轴和Y轴上标记true和false，并绘制出这四个点。如果你做得对，则会得到像这样的东西：

现在（也许你不知道神经元的这种解释），尝试将神经元绘制为平面上的一条线，它可以按照你需要的方式分隔你的点。例如，这是AND运算的线：该线将正确答案与错误答案分隔开来。如果你理解了，你可以编写OR的线。XOR将更麻烦。

最后一个调试步骤是将神经元视为一条线。找到相关文献，我不记得如何通过现有的线构建神经元。这很简单。然后为AND构建一个神经元向量并实现它。将AND实现为单个神经元网络，其中神经元定义为在纸上计算得到的AND。如果你做得对，你的网络将执行AND函数。我写了这么多字只是因为你在理解任务之前就编写程序。我不想粗暴，但你提到XOR时表明了这一点。如果你尝试在一个神经元中构建XOR，你将什么都得不到——正确答案与错误答案无法分开。在书籍中，它被称为“XOR不是线性可分的”。因此，对于XOR，你需要构建一个两层网络。例如，你将使用AND和not-OR作为第一层，并使用AND作为第二层。

如果你仍在阅读并且理解了我写的内容，那么你在调试网络方面将没有任何问题。如果你的网络无法学习某些功能，则在纸上构建该功能，然后硬编码你的网络并测试它。如果它仍然失败，则你在纸上构建它时可能是有误的，请重新阅读我的讲座；）

- Alex Teut

---

看起来，问题中的代码有四个节点，分为两层：一个由三个节点组成的中间层和一个由一个节点组成的输出层。 - Wayne Conrad

好的，谢谢。我没有仔细阅读代码。所以快速的答案可能是：尝试从两个节点创建中间层，并重新运行您的算法。 - Alex Teut

Answer 2

我遇到过同样的问题，答案是 - 使用更高的学习速度。 我使用以下代码： lSpeed = 12.8 / epoch以及大约100个epoches用于具有phi(x) = x/(1 + |x|)的神经网络。

可能现在你的NN学习速度不够强大，无法完成任务。

- Marat Zakirov

Answer 3

如果您想考虑神经进化，可以查看neuroevo gem。运行规范以查看它如何在15次迭代中适合 XOR ([2,2,1] 前馈网络，XNES 优化器)：

https://github.com/giuse/neuroevo/blob/master/spec/solver_spec.rb

全面披露：我是开发人员（你好！）。
我最近刚开始发布我的代码，并正在寻求反馈意见。

- Giuse