Algorithm 神经网络采用批量训练算法，当应用动量和权值衰减时

我建立了一个神经网络，并使用随机梯度下降的反向传播成功地训练了它。现在我正转向批量训练，但我对何时应用动量和重量衰减有点困惑。 我很清楚反向传播在理论上是如何工作的，我只是停留在实现细节上。 使用随机方法，我所要做的就是在计算梯度后立即对权重应用更新，如下面的伪python代码：

for epoch in epochs:
    for p in patterns:
        outputs = net.feedforward(p.inputs)
        # output_layer_errors is needed to plot the error
        output_layer_errors = net.backpropagate(outputs, p.targets)
        net.update_weights()

其中，更新_权重方法定义如下：

def update_weights(self):
    for h in self.hidden_neurons:
        for o in self.output_neurons:
            gradient = h.output * o.error
            self.weights[h.index][o.index] += self.learning_rate * gradient + \
                                              self.momentum * self.prev_gradient
            self.weights[h.index][o.index] -= self.decay * self.weights[h.index][o.index]

    for i in self.input_neurons:
        for h in self.hidden_neurons:
            gradient = i.output * h.error
            self.weights[i.index][h.index] += self.learning_rate * gradient + \
                                              self.momentum * self.prev_gradient
            self.weights[i.index][h.index] -= self.decay * self.weights[i.index][h.index]

def accumulate_weights(self):
    for h in self.hidden_neurons:
        for o in self.output_neurons:
            gradient = h.output * o.error
            self.accumulator[h.index][o.index] += self.learning_rate * gradient
            # should I compute momentum here?
    for i in self.input_neurons:
        for h in self.hidden_neurons:
            gradient = i.output * h.error
            # should I just accumulate the gradient without scaling it by the learning rate here?
            self.accumulator[i.index][h.index] = self.learning_rate * gradient
            # should I compute momentum here?

这就像一个符咒（请注意，可能会有错误，因为我只是使用python，因为它更容易理解，实际的网络是用C编码的。这段代码只是为了显示我计算更新的步骤）。 现在，切换到批量更新，主要算法应该是：

for epoch in epochs:
    for p in patterns:
        outputs = net.feedforward(p.inputs)
        # output_layer_errors is needed to plot the error
        output_layer_errors = net.backpropagate(outputs, p.targets)
        net.accumulate_updates()
    net.update_weights()

累积法如下：

def update_weights(self):
    for h in self.hidden_neurons:
        for o in self.output_neurons:
            gradient = h.output * o.error
            self.weights[h.index][o.index] += self.learning_rate * gradient + \
                                              self.momentum * self.prev_gradient
            self.weights[h.index][o.index] -= self.decay * self.weights[h.index][o.index]

    for i in self.input_neurons:
        for h in self.hidden_neurons:
            gradient = i.output * h.error
            self.weights[i.index][h.index] += self.learning_rate * gradient + \
                                              self.momentum * self.prev_gradient
            self.weights[i.index][h.index] -= self.decay * self.weights[i.index][h.index]

def accumulate_weights(self):
    for h in self.hidden_neurons:
        for o in self.output_neurons:
            gradient = h.output * o.error
            self.accumulator[h.index][o.index] += self.learning_rate * gradient
            # should I compute momentum here?
    for i in self.input_neurons:
        for h in self.hidden_neurons:
            gradient = i.output * h.error
            # should I just accumulate the gradient without scaling it by the learning rate here?
            self.accumulator[i.index][h.index] = self.learning_rate * gradient
            # should I compute momentum here?

更新的权重如下所示：

def update_weights(self):
    for h in self.hidden_neurons:
        for o in self.output_neurons:
            # what to do here? apply momentum? apply weight decay?
            self.weights[h.index][o.index] += self.accumulator[h.index][o.index]
            self.accumulator[h.index][o.index] = 0.0

    for i in self.input_neurons:
        for h in self.hidden_neurons:
            # what to do here? apply momentum? apply weight decay?
            self.weights[i.index][h.index] += self.accumulator[i.index][h.index]
            self.accumulator[i.index][h.index] = 0.0

我不确定我是否必须：

1） 使用累积时或更新时的学习率缩放梯度

2） 在更新时累积时应用动量

3） 与2）相同，但用于重量衰减

有人能帮我解决这个问题吗？

---

很抱歉问了这么长的问题，但我想我会详细解释我的疑问。

只是对这一点的一些简短评论。随机梯度下降在大多数情况下会导致非光滑优化，并且需要顺序优化，这不适合当前的技术进步，例如并行计算

因此，小批量方法试图利用批量优化（并行计算）的优点来获得随机优化的优点。在这里，您要做的是创建小的训练块，以与学习算法并行的方式进行训练。最后，每个工人都应该告诉您他们的训练样本的误差，您可以将其平均化，并将其用作正常随机梯度下降

---

这种方法会导致更平滑的优化，如果您使用并行计算，可能会导致更快的优化。

请快速评论一下。随机梯度下降在大多数情况下会导致非光滑优化，并且需要顺序优化，这不适合当前的技术进步，例如并行计算

因此，小批量方法试图利用批量优化（并行计算）的优点来获得随机优化的优点。在这里，您要做的是创建小的训练块，以与学习算法并行的方式进行训练。最后，每个工人都应该告诉您他们的训练样本的误差，您可以将其平均化，并将其用作正常随机梯度下降

---

这种方法会导致更平滑的优化，如果您使用并行计算，可能会导致更快的优化。

请快速评论一下。随机梯度下降在大多数情况下会导致非光滑优化，并且需要顺序优化，这不适合当前的技术进步，例如并行计算

因此，小批量方法试图利用批量优化（并行计算）的优点来获得随机优化的优点。在这里，您要做的是创建小的训练块，以与学习算法并行的方式进行训练。最后，每个工人都应该告诉您他们的训练样本的误差，您可以将其平均化，并将其用作正常随机梯度下降

---

这种方法会导致更平滑的优化，如果您使用并行计算，可能会导致更快的优化。

请快速评论一下。随机梯度下降在大多数情况下会导致非光滑优化，并且需要顺序优化，这不适合当前的技术进步，例如并行计算

因此，小批量方法试图利用批量优化（并行计算）的优点来获得随机优化的优点。在这里，您要做的是创建小的训练块，以与学习算法并行的方式进行训练。最后，每个工人都应该告诉您他们的训练样本的误差，您可以将其平均化，并将其用作正常随机梯度下降

---

如果使用并行计算，这种方法会导致更平滑的优化，并且可能会导致更快的优化。

对于第一个问题，两种方法似乎都可以。但是，如果您想与动量相结合，最好在实现中检查原始公式。我想说的是，你不应该在积累过程中缩放梯度。计算动量时，使用以下公式：

v_{t+1} = \mu v_t - \alpha * g_t

其中g_t是梯度。阿尔法是学习率

我还建议使用AdaGrad和mini batch而不是full batch

---

参考资料：

第一个问题似乎也可以。但是，如果您想与动量相结合，最好在实现中检查原始公式。我想说的是，你不应该在积累过程中缩放梯度。计算动量时，使用以下公式：

v_{t+1} = \mu v_t - \alpha * g_t

其中g_t是梯度。阿尔法是学习率

我还建议使用AdaGrad和mini batch而不是full batch

---

参考资料：

第一个问题似乎也可以。但是，如果您想与动量相结合，最好在实现中检查原始公式。我想说的是，你不应该在积累过程中缩放梯度。计算动量时，使用以下公式：

v_{t+1} = \mu v_t - \alpha * g_t

其中g_t是梯度。阿尔法是学习率

我还建议使用AdaGrad和mini batch而不是f