python - 神经网络中梯度计算的问题(MNIST 中的误差为 7%)

Question

您好，我在使用 numpy 在 python 中实现神经网络时检查梯度的计算遇到问题。 我正在使用 mnist 数据集来尝试使用小批量梯度下降。

我已经检查了数学，在纸上看起来不错，所以也许你可以给我一些关于这里发生的事情的提示:

编辑:一个答案让我意识到成本函数确实计算错误。然而，这并不能解释梯度的问题，因为它是使用 back_prop 计算的。我在隐藏层中使用 300 个单元，使用 小批量梯度 下降和 rmsprop、30 个周期和 100 个批处理，得到 %7 错误率。 (learning_rate = 0.001，由于 rmsprop 而较小)。

每个输入都有 768 个特征，因此对于 100 个样本，我有一个矩阵。 Mnist 有 10 个类。

X = NoSamplesxFeatures = 100x768

Y = NoSamplesxClasses = 100x10

我使用的是单隐藏层神经网络，完全训练时隐藏层大小为 300。我的另一个问题是我是否应该使用 softmax 输出函数来计算误差......我认为不应该。但我对这一切都有点新手，而且显而易见的事情对我来说可能看起来很奇怪。

(注意:我知道代码很难看，但这是我在压力下完成的第一个 Python/Numpy 代码，请耐心等待)

这是 back_prof 和激活:

  def sigmoid(z):
     return np.true_divide(1,1 + np.exp(-z) )

  #not calculated really - this the fake version to make it faster. 
  def sigmoid_prime(a):
     return  (a)*(1 - a)

  def _back_prop(self,W,X,labels,f=sigmoid,fprime=sigmoid_prime,lam=0.001):

    """
    Calculate the partial derivates of the cost function using backpropagation.
    """     
    #Weight for first layer and hidden layer
    Wl1,bl1,Wl2,bl2  = self._extract_weights(W)


    # get the forward prop value
    layers_outputs = self._forward_prop(W,X,f)

    #from a number make a binary vector, for mnist 1x10 with all 0 but the number.
    y = self.make_1_of_c_encoding(labels)
    num_samples = X.shape[0] # layers_outputs[-1].shape[0]

    # Dot product return  Numsamples (N) x Outputs (No CLasses)
    # Y is NxNo Clases
    # Layers output to


    big_delta = np.zeros(Wl2.size + bl2.size + Wl1.size + bl1.size)
    big_delta_wl1, big_delta_bl1, big_delta_wl2, big_delta_bl2 = self._extract_weights(big_delta)


    # calculate the gradient for each training sample in the batch and accumulate it

    for i,x in enumerate(X):

        # Error with respect  the output
        dE_dy =  layers_outputs[-1][i,:] -  y[i,:] 

        # bias hidden layer
        big_delta_bl2 +=   dE_dy


        # get the error for the hiddlen layer
        dE_dz_out  = dE_dy * fprime(layers_outputs[-1][i,:])

        #and for the input layer
        dE_dhl = dE_dy.dot(Wl2.T)

        #bias input layer
        big_delta_bl1 += dE_dhl

        small_delta_hl = dE_dhl*fprime(layers_outputs[-2][i,:])

        #here calculate the gradient for the weights in the hidden and first layer
        big_delta_wl2 += np.outer(layers_outputs[-2][i,:],dE_dz_out)
        big_delta_wl1 +=   np.outer(x,small_delta_hl)





    # divide by number of samples in the batch (should be done here)?
    big_delta_wl2 = np.true_divide(big_delta_wl2,num_samples) + lam*Wl2*2
    big_delta_bl2 = np.true_divide(big_delta_bl2,num_samples)
    big_delta_wl1 = np.true_divide(big_delta_wl1,num_samples) + lam*Wl1*2
    big_delta_bl1 = np.true_divide(big_delta_bl1,num_samples)

    # return 
    return np.concatenate([big_delta_wl1.ravel(),
                           big_delta_bl1,
                           big_delta_wl2.ravel(),
                           big_delta_bl2.reshape(big_delta_bl2.size)])

现在是 feed_forward:

def _forward_prop(self,W,X,transfer_func=sigmoid):
    """
    Return the output of the net a Numsamples (N) x Outputs (No CLasses)
    # an array containing the size of the output of all of the laye of the neural net
    """

    # Hidden layer DxHLS
    weights_L1,bias_L1,weights_L2,bias_L2 = self._extract_weights(W)    

    # Output layer HLSxOUT

    # A_2 = N x HLS
    A_2 = transfer_func(np.dot(X,weights_L1) + bias_L1 )

    # A_3 = N x  Outputs
    A_3 = transfer_func(np.dot(A_2,weights_L2) + bias_L2)

    # output layer
    return [A_2,A_3]

以及梯度检查的成本函数:

 def cost_function(self,W,X,labels,reg=0.001):
    """
    reg: regularization term
    No weight decay term - lets leave it for later
    """

    outputs = self._forward_prop(W,X,sigmoid)[-1] #take the last layer out
    sample_size = X.shape[0]

    y = self.make_1_of_c_encoding(labels)

    e1 = np.sum((outputs - y)**2, axis=1))*0.5

    #error = e1.sum(axis=1)
    error = e1.sum()/sample_size + 0.5*reg*(np.square(W)).sum()

    return error

Answer 1

运行梯度检查时会得到什么样的结果？很多时候，您可以通过查看梯度的输出与梯度检查产生的输出来梳理实现错误的本质。

此外，对于 MNIST 等分类任务来说，平方误差通常不是一个好的选择，我建议使用简单的 sigmoid 顶层或 softmax。对于 sigmoid，您要使用的交叉熵函数是:

L(h,Y) = -Y*log(h) - (1-Y)*log(1-h)

对于 softmax

L(h,Y) = -sum(Y*log(h))

其中 Y 是以 1x10 向量给出的目标，h 是您的预测值，但可以轻松扩展到任意批量大小。

在这两种情况下，顶层增量都会变成:

delta = h - Y

顶层渐变变为:

grad = dot(delta, A_in)

其中 A_in 是从上一层到顶层的输入。

虽然我在理解你的反向传播例程时遇到了一些麻烦，但我从你的代码中怀疑梯度错误是由于你在使用平方误差时没有正确计算顶级 dE/dw_l2 ，以及在不正确的输入上计算 fprime。

当使用平方误差时，顶层增量应该是:

delta = (h - Y) * fprime(Z_l2)

此处 Z_l2 是第 2 层传递函数的输入。同样，在计算较低层的 fprime 时，您希望使用传递函数的输入(即 dot(X,weights_L1) +bias_L1)

希望有帮助。

编辑: 作为使用交叉熵误差而不是平方误差的一些补充理由，我建议查找 Geoffrey Hinton 关于线性分类方法的讲座: www.cs.toronto.edu/~hinton/csc2515/notes/lec3.ppt

编辑2: 我使用 RMSPROP 在具有不同参数和 1 个隐藏层的 MNIST 数据集上实现神经网络，在本地运行了一些测试。结果如下:

Test1
Epochs: 30
Hidden Size: 300 
Learn Rate: 0.001
Lambda: 0.001
Train Method: RMSPROP with decrements=0.5 and increments=1.3 
Train Error: 6.1%
Test Error: 6.9%

Test2
Epochs: 30
Hidden Size: 300 
Learn Rate: 0.001
Lambda: 0.000002
Train Method: RMSPROP with decrements=0.5 and increments=1.3 
Train Error: 4.5%
Test Error: 5.7%

看来，如果将 lambda 参数减少几个数量级，最终应该会获得更好的性能。