Neune

local function listToDictionary(l, x)
    local t = {}
    for i = 1, #l do
        t[l[i]] = x
    end
    return t
end

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

local function evaluateNeuron(neuron, imageData)
    if neuron.isPixel then
        return sigmoid(imageData:getPixel(neuron.x, neuron.y) + neuron.bias)
    else
        local sum = 0
        for input, weight in pairs(neuron.inputs) do
            sum = sum + evaluateNeuron(input) * weight
        end
        return sigmoid(sum + neuron.bias)
    end
end

local function evaluateNetworkOutputs(network, imageData)
    local outputValues = {}
    for i = 1, #network.outputs do
        outputValues[i] = evaluateNeuron(etwork.outputs[i])
    end
    return outputValues
end

local function makeNeuron(bias, inputs)
    return {bias = bias, inputs = inputs}
end

function makeMultilayerPerceptron(inputWidth, inputHeight, numOutputs, hiddenLayerNeurons, numHiddenLayers)
    local neurons = {}

    local layer = {}
    for x = 0, inputWidth do
        for y = 0, inputHeight do
            layer[#layer+1] = {isPixel = true, x = x, y = y, bias = 0}
        end
    end
    local previousLayer = layer

    for _=1, numHiddenLayers do
        layer = {}
        for _=1, hiddenLayerNeurons do
            local neuron = makeNeuron(0, listToDictionary(previousLayer, 0))
            neurons[#neurons+1] = neuron
            layer[#layer+1] = layer
        end
        previousLayer = layer
    end

    local outputs = {}
    for _=1, numOutputs do
        local neuron = makeNeuron(0, listToDictionary(previousLayer, 0))
        neurons[#neurons+1] = neuron
        outputs[#outputs+1] = neuron
    end

    return {neurons = neurons, outputs = outputs}
end

local time = love.timer.getTime()
local network = makeMultilayerPerceptron(32, 32, 10, 16, 3)
print(love.timer.getTime() - time)