我能'；我真的搞不懂什么'；我的神经网络课（Lua）出了什么问题

我写了这节神经网络课。 我使用了类库和矩阵库 分别

对我来说似乎都是正确的（至少在理想情况下是如此），顺便说一句，当我实例化一个新的神经网络，有2个输入，2个隐藏的神经元和1个输出，并试图解决一个异或，它不起作用

我错过了什么？也许我误解了矩阵库，希望有人能帮助我

编辑： 我在库中添加了一个map函数，将一个数学函数应用于矩阵中的每个数字

local matrix = require("matrixx")
local Class = require("class")
NeuralNetwork = Class{}

function NeuralNetwork:init(input_nodes, hidden_nodes, output_nodes)
    self.input_nodes = input_nodes
    self.hidden_nodes = hidden_nodes
    self.output_nodes = output_nodes

    self.weights_ih = matrix(self.hidden_nodes, self.input_nodes, math.random())
    self.weights_ho = matrix(self.output_nodes, self.hidden_nodes, math.random())

    self.bias_h = matrix(self.hidden_nodes, 1, math.random())
    self.bias_o = matrix(self.output_nodes, 1, math.random())


    self.learning_rate = 0.1
end

function NeuralNetwork:feedforward(input_array)
    --Generating the Hidden Outputs
    local inputs = matrix(input_array)
    for i=1, #input_array do
        inputs[i][1] = input_array[i]
    end

    local hidden = self.weights_ih * inputs
    hidden = hidden + self.bias_h

    --Activation Function
    hidden = matrix.map(hidden, tanh)

    --Generating the output's output
    local output = self.weights_ho * hidden
    output = output + self.bias_o
    output = matrix.map(output, tanh)

    return output
end

function NeuralNetwork:train(input_array, target_array)

    --Generating the Hidden Outputs
    local inputs = matrix(input_array)
    for i=1, #input_array do
        inputs[i][1] = input_array[i]
    end

    local hidden = self.weights_ih * inputs
    hidden = hidden + self.bias_h

    --Activation Function
    hidden = matrix.map(hidden, tanh)

    --Generating the output's output
    local outputs = self.weights_ho * hidden
    outputs = outputs + self.bias_o
    outputs = matrix.map(outputs, tanh)

    --Convert Targets Array to Matrix object
    local targets = matrix(#target_array, 1)
    for i=1, #target_array do
        targets[i][1] = target_array[i]
    end

    --Calculate the error
    local output_errors = targets - outputs

    --Calculate gradient
    local gradients = matrix.map(outputs, tanhd)
    gradients = gradients * output_errors
    gradients = gradients * self.learning_rate

    -- Calculate deltas
    local hidden_T = matrix.transpose(hidden)

    local weight_ho_deltas = gradients * hidden_T

    -- Adjust the weights by deltas
    self.weights_ho = self.weights_ho + weight_ho_deltas
    -- Adjust the bias by its deltas (which is just the gradients)
    self.bias_o = self.bias_o + gradients

    -- Calculate the hidden layer errors
    local who_t = matrix.transpose(self.weights_ho)
    local hidden_errors = who_t * output_errors

    -- Calculate hidden gradient
    local hidden_gradient = matrix.map(hidden, tanhd)
    hidden_gradient = hidden_gradient * hidden_errors * self.learning_rate

    -- Calcuate input->hidden deltas
    local inputs_T = matrix.transpose(inputs)
    local weight_ih_deltas = hidden_gradient * inputs_T

    self.weights_ih = self.weights_ih + weight_ih_deltas
    -- Adjust the bias by its deltas (which is just the gradients)
    self.bias_h = self.bias_h + hidden_gradient

    self.weights_ih:print()
    print()
    self.weights_ho:print()
    print()
end

function sigmoid(x)
    return 1 / (1 + math.exp(-x))
end

function dsigmoid(x)
    return sigmoid(x) * (1 - sigmoid(x))
end

function tanh(x)
    return (math.exp(x) - math.exp(-x)) / (math.exp(x) + math.exp(-x))
end

function tanhd(x)
    return 1 / math.cosh(x)^2
end

--MAIN
local nn = NeuralNetwork(2, 2, 1)
local training_data = {
    {
        inputs = {0, 1},
        target = {1}
    },
    {
        inputs = {1, 1},
        target = {0}
    },
    {
        inputs = {1, 0},
        target = {1}
    },
    {
        inputs = {0, 0},
        target = {0}
    }
}

for i = 1, 30 do
    local data = training_data[math.floor(math.random(#training_data))]
    nn:train(data.inputs, data.target)
end
nn:feedforward({0, 1}):print()
nn:feedforward({1, 1}):print()
nn:feedforward({0, 0}):print()
nn:feedforward({1, 0}):print()

---

当你实例化它时，会发生什么？模块

矩阵中没有函数
matrix.map
。lua

。dan:它应该用给定的（输入、隐藏的神经元、输出）创建一个新的神经网络@EgorSkriptunoff哦，对了！谢谢我创建了这个函数。它将函数应用于矩阵中的每个数字。我对它进行了测试，效果良好。我将编辑我的问题，谢谢。顺便说一句，当您的NN有3个以上的输入时，

local inputs=matrix（input\u array）

这一行是一个主题。幸运的是，它不适用于当前非常小的NN。您的错误在

局部梯度=矩阵.map（outputs，tanhd）

行中，您正在将

tanh

的结果传递给

tanhd

（您应该将

tanh

的参数传递给

tanhd

）。换句话说，你有

f'（f（x））

而不是

f'（x）

function matrix.map( m1, func )
    local mtx = {}

    for i = 1,#m1 do
        mtx[i] = {}
        for j = 1,#m1[1] do
            mtx[i][j] = func(m1[i][j])
        end
    end
    return setmetatable( mtx, matrix_meta )
end