Relu表现比sigmoid更差？

Question

我对所有图层和输出使用sigmoid，并得到0.00012的最终错误率，但是当我使用Relu时，理论上更好，我得到可能的最差结果。任何人都可以解释为什么会发生？我使用的网站100可用一个非常简单的2层实现的代码，但仍然很下面给它，

import numpy as np 
#test 
#avg(nonlin(np.dot(nonlin(np.dot([0,0,1],syn0)),syn1))) 
#returns list >> [predicted_output, confidence] 
def nonlin(x,deriv=False):#Sigmoid 
    if(deriv==True): 
     return x*(1-x) 

    return 1/(1+np.exp(-x)) 

def relu(x, deriv=False):#RELU 
    if (deriv == True): 
     for i in range(0, len(x)): 
      for k in range(len(x[i])): 
       if x[i][k] > 0: 
        x[i][k] = 1 
       else: 
        x[i][k] = 0 
     return x 
    for i in range(0, len(x)): 
     for k in range(0, len(x[i])): 
      if x[i][k] > 0: 
       pass # do nothing since it would be effectively replacing x with x 
      else: 
       x[i][k] = 0 
    return x 

X = np.array([[0,0,1], 
      [0,0,0], 
      [0,1,1], 
      [1,0,1], 
      [1,0,0], 
      [0,1,0]]) 

y = np.array([[0],[1],[0],[0],[1],[1]]) 

np.random.seed(1) 

# randomly initialize our weights with mean 0 
syn0 = 2*np.random.random((3,4)) - 1 
syn1 = 2*np.random.random((4,1)) - 1 

def avg(i): 
     if i > 0.5: 
      confidence = i 
      return [1,float(confidence)] 
     else: 
      confidence=1.0-float(i) 
      return [0,confidence] 
for j in xrange(500000): 

    # Feed forward through layers 0, 1, and 2 
    l0 = X 
    l1 = nonlin(np.dot(l0,syn0Performing)) 
    l2 = nonlin(np.dot(l1,syn1)) 
    #print 'this is',l2,'\n' 
    # how much did we miss the target value? 
    l2_error = y - l2 
    #print l2_error,'\n' 
    if (j% 100000) == 0: 
     print "Error:" + str(np.mean(np.abs(l2_error))) 
     print syn1 

    # in what direction is the target value? 
    # were we really sure? if so, don't change too much. 
    l2_delta = l2_error*nonlin(l2,deriv=True) 

    # how much did each l1 value contribute to the l2 error (according to the weights)? 
    l1_error = l2_delta.dot(syn1.T) 

    # in what direction is the target l1? 
    # were we really sure? if so, don't change too much. 
    l1_delta = l1_error * nonlin(l1,deriv=True) 

    syn1 += l1.T.dot(l2_delta) 
    syn0 += l0.T.dot(l1_delta) 
print "Final Error:" + str(np.mean(np.abs(l2_error))) 
def p(l): 
     return avg(nonlin(np.dot(nonlin(np.dot(l,syn0)),syn1))) 

因此P（x）是教育训练，其中x是一个1×3矩阵后的预测中功能输入值。

Answer 1

你为什么说理论上更好？在大多数应用中，ReLU已被证明更好，但并不意味着它通用性更好。你的例子非常简单，输入在[0,1]之间缩放，与输出相同。这正是我希望sigmoid表现良好的地方。由于渐变问题消失以及大型网络中的其他问题，您在实践中不会遇到隐藏层中的S形，但这对您来说不是问题。

此外，如果您有任何机会使用ReLU衍生物，您在代码中缺少'其他'。你的派生将被简单覆盖。

就像复习，这里的RELU的定义：

F（X）= MAX（0，x）的

...这意味着它可以吹你激活无限。你想避免在最后（输出）层上有ReLU。

在一个侧面说明，只要有可能，你应该采取矢量化操作的优势：

def relu(x, deriv=False):#RELU 
    if (deriv == True): 
     mask = x > 0 
     x[mask] = 1 
     x[~mask] = 0 
    else: # HERE YOU WERE MISSING "ELSE" 
     return np.maximum(0,x) 

是的，这是多更快然后if/else语句，你在干什么。