Question

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

我已经检查了数学并且在纸上看起来很好，所以也许你可以给我一些关于这里发生了什么的提示：

编辑：一个答案让我意识到成本函数的计算确实是错误的。 Howerver没有解释梯度问题，因为它是使用back_prop计算的。我使用minibatch gradient下降rmsprop，30个纪元和100个批次，使用隐藏层中的300个单位获得％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是前一层的顶层输入。

虽然我在使用backprop例程时遇到了一些麻烦，但我怀疑你的代码中渐变的错误是由于你在使用平方误差时没有正确计算顶级dE / dw_l2的事实，以及在错误输入上计算fprime。

使用方差时，顶层delta应为：

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

此处Z_l2是第2层传递函数的输入。类似地，当计算较低层的fprime时，您希望使用传递函数的输入（即点（X，weights_L1）+ bias_L1）

希望有所帮助。

编辑：由于一些使用交叉熵误差超过平方误差的理由我建议查找Geoffrey Hinton关于线性分类方法的讲座： www.cs.toronto.edu/~hinton/csc2515/notes/lec3.ppt

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

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参数减少几个数量级，最终会有更好的表现。

神经网络中的梯度计算问题（在MNIST中误差为7％）

1 个答案: