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

我正在尝试使用实现反向传播算法的资源来实现自动编码器。我使用的是在那里实现的相同的前馈算法，但是它给了我一个很大的错误。在自动编码器中，应用于隐藏编码和输出解码的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个纪元后没有改变。问题的特征（例如错误在100个纪元内几乎没有改变，并且仍然存在一个大错误）表明，问题可能是（也可能是）由输入数据的大小顺序以及使用乙状结肠作为激活函数的事实造成的。我将给你一个简单的例子：

假设我要重建值

x=100

。 如果我在单个神经元上用自动编码器训练它，重构的输出将由

r=sigmoid（w*x）

给出，其中误差是实际输入和重构之间的差异，即

e=x-r

。请注意，由于sigmoid函数的边界在-1和1之间，因此在这种情况下，您可以得到的最小误差是

e=100-1=99

。在这种情况下，无论你训练的重量有多好，

r=sigmoid（w*x）

总是以一为界

这意味着在这种情况下，sigmoid激活函数无法表示您的数据。 要解决此问题，请执行以下操作之一：

将输入数据缩小或规格化为-1到1之间的大小，或

将sigmoid更改为另一个激活函数，它实际上可以重建数据顺序的正确大小

希望这有帮助