使用反向传播的自动编码器

我正在尝试使用this资源实现自动编码器，该资源实现了反向传播算法 . 我在那里使用了相同的前馈算法但是它给了我一个很大的错误 . 在Autoencoders中，sigmoid函数应用于隐藏进行编码，再次应用于输出进行解码 .

def feedForwardPropagation(network, row, output=False):
currentInput = row
if not output:
    layer = network[0]
else:
    layer = network[1]
layer_output = []
for neuron in layer:
    activation = neuron_activation(neuron['weights'], currentInput)
    neuron['output'] = neuron_transfer(activation)
    layer_output.append(neuron['output'])
currentInput = layer_output
return currentInput

def backPropagationNetworkErrorUpdate(network, expected):
for i in reversed(range(len(network))):
    layer = network[i]
    errors = list()
    if i != len(network) - 1:
        # Hidden Layers weight error compute
        for j in range(len(layer)):
            error = 0.0
            for neuron in network[i + 1]:  # It starts with computing weight error of output neuron.
                error += (neuron['weights'][j] * neuron['delta'])
            errors.append(error)
    else:
        # Output layer error computer
        for j in range(len(layer)):
            neuron = layer[j]
            error = expected[j] - neuron['output']
            errors.append(error)
    for j in range(len(layer)):
        neuron = layer[j]
        transfer = neuron['output'] * (1.0 - neuron['output'])
        neuron['delta'] = errors[j] * transfer

def updateWeights(network, row, l_rate, momentum=0.5):
for i in range(len(network)):
    inputs = row[:-1]
    if i != 0:
        inputs = [neuron['output'] for neuron in network[i - 1]]
    for neuron in network[i]:
        for j in range(len(inputs)):
            neuron['velocity'][j] = momentum * neuron['velocity'][j] + l_rate * neuron['delta'] * inputs[j]
            neuron['weights'][j] += neuron['velocity'][j]
        neuron['velocity'][-1] = momentum * neuron['velocity'][-1] + l_rate * neuron['delta'] * inputs[j]
        neuron['weights'][-1] += neuron['velocity'][-1]


def trainNetwork(network, train, l_rate, n_epoch, n_outputs, test_set):
hitrate = list()
errorRate = list()
epoch_step = list()
for epoch in range(n_epoch):
    sum_error = 0
    np.random.shuffle(train)
    for row in train:
        outputs = feedForwardPropagation(network, row)
        outputs = feedForwardPropagation(network, outputs)
        expected = row
        sum_error += sum([(expected[i] - outputs[i]) ** 2 for i in range(len(expected))])
        backPropagationNetworkErrorUpdate(network, expected)
        updateWeights(network, row, l_rate)
    if epoch % 10 == 0:
        errorRate.append(sum_error)
        epoch_step.append(epoch)
        log = '>epoch=%d, lrate=%.3f, error=%.3f' % (epoch, l_rate, sum_error)
        print(log, n_epoch, len(network[1][0]['weights']) - 1, l_rate)
return epoch_step, errorRate

对于自动编码，我使用一个隐藏层，n个输入和n个输出 . 我相信我在前馈实现方面出了问题 . 任何建议将不胜感激 .

编辑：我尝试在第一层之后计算权重（在前馈方法中继续注释），然后使用在trainNetwork方法中注释的sigmoid函数解码输出 . 但是，错误在100个时期后没有改变