2

在 n 层神经网络中计算梯度的好方法是什么？

权重层：

  1. 第一层权重：     (n_inputs+1, n_units_layer)-matrix
  2. 隐藏层权重：(n_units_layer+1, n_units_layer)-matrix
  3. 最后一层权重：     (n_units_layer+1, n_outputs)-matrix

笔记：

  • 如果只有一个隐藏层，我们将只使用两个（权重）层来表示网络：
    inputs --first_layer-> network_unit --second_layer-> output
  • 对于具有多个隐藏层的 n 层网络，我们需要实现 (2) 步骤。

有点模糊的伪代码：

    weight_layers = [ layer1, layer2 ]             # a list of layers as described above
    input_values  = [ [0,0], [0,0], [1,0], [0,1] ] # our test set (corresponds to XOR)
    target_output = [ 0, 0, 1, 1 ]                 # what we want to train our net to output
    output_layers = []                             # output for the corresponding layers

    for layer in weight_layers:
        output <-- calculate the output     # calculate the output from the current layer
        output_layers <-- output            # store the output from each layer
    
    n_samples = input_values.shape[0]
    n_outputs = target_output.shape[1]
    
    error = ( output-target_output )/( n_samples*n_outputs )

    """ calculate the gradient here """

最终实施

最终实现可在 github 获得。

4

1 回答 1

2

使用 Python 和 numpy 很容易。

你有两个选择：

  1. 您可以为num_instances实例并行计算所有内容，或者
  2. 您可以计算一个实例的梯度（这实际上是 1. 的一个特例）。

我现在将给出一些提示如何实现选项 1。我建议您创建一个名为Layer. 它应该有两个功能：

向前：
    输入：
    X: 形状 = [num_instances, num_inputs]
        输入
    W: 形状 = [num_outputs, num_inputs]
        权重
    b: 形状 = [num_outputs]
        偏见
    克：功能
        激活函数
    输出：
    Y: 形状 = [num_instances, num_outputs]
        输出


反向传播：
    输入：
    dE/dY: 形状 = [num_instances, num_outputs]
        反向传播梯度
    W: 形状 = [num_outputs, num_inputs]
        权重
    b: 形状 = [num_outputs]
        偏见
    gd：函数
        计算 g(A) = Y 的导数
        基于Y，即gd(Y) = g'(A)
    Y: 形状 = [num_instances, num_outputs]
        输出
    X: 形状 = [num_instances, num_inputs]
        输入
    输出：
    dE/dX：形状 = [num_instances, num_inputs]
        将被反向传播（下层的 dE/dY）
    dE/dW：形状 = [num_outputs, num_inputs]
        关于权重的累积导数
    dE/db：形状 = [num_outputs]
        关于偏差的累积导数

实现很简单：

def forward(X, W, b):
    A = X.dot(W.T) + b # will be broadcasted
    Y = g(A)
    return Y

def backprop(dEdY, W, b, gd, Y, X):
    Deltas = gd(Y) * dEdY # element-wise multiplication
    dEdX = Deltas.dot(W)
    dEdW = Deltas.T.dot(X)
    dEdb = Deltas.sum(axis=0)
    return dEdX, dEdW, dEdb

X第一层是您从数据集中获取的，然后您将每一层Y作为X前向传递中的下一层传递。

计算dE/dY输出层的 （对于 softmax 激活函数和交叉熵误差函数，或者对于线性激活函数和平方误差之和）Y-T，其中Y是网络的输出 (shape = [num_instances, num_outputs]) 和T(shape = [num_instances, num_outputs]) 是所需的输出。然后你可以反向传播，即dE/dX每一层都是dE/dY前一层。

现在您可以使用每一层的 and 来dE/dW更新and 。dE/dbWb

这是 C++ 的一个示例：OpenANN。

顺便提一句。您可以比较实例和批量前向传播的速度：

In [1]: import timeit

In [2]: setup = """import numpy
   ...: W = numpy.random.rand(10, 5000)
   ...: X = numpy.random.rand(1000, 5000)"""

In [3]: timeit.timeit('[W.dot(x) for x in X]', setup=setup, number=10)
Out[3]: 0.5420958995819092

In [4]: timeit.timeit('X.dot(W.T)', setup=setup, number=10)
Out[4]: 0.22001314163208008
于 2013-06-11T19:55:06.730 回答