ReLU 不一致/随机行为

问题描述

我写了一个简单的nn（它应该添加两个数字）并且我尝试了不同的激活函数，这是我的代码

class Layer:
    def __init__(self):
        self.inputs = None

def forward(self,inputs):
    pass

def backward(self,error_gradient,lr):
    pass

class Dense(Layer):
    def __init__(self,n_inputs,n_neurons):
        self.weights = np.random.randn(n_neurons,n_inputs)
        self.biases = np.random.randn(n_neurons,1)
        super().__init__()

    def forward(self,inputs):
        self.inputs = inputs
        return np.dot(self.weights,self.inputs) + self.biases

    def backward(self,lr):
        weight_deriv = np.dot(error_gradient,self.inputs.T)
        self.weights -= lr * weight_deriv
        self.biases -= lr * self.biases
        return np.dot(self.weights.T,error_gradient)

class Activation(Layer):
    def __init__(self,activation,actiovation_prime):
        self.activation = activation
        self.activation_prime = actiovation_prime
        super().__init__()

    def forward(self,inputs):
        self.inputs = inputs
        return self.activation(self.inputs)

    def backward(self,lr):
        return np.multiply(error_gradient,self.activation_prime(self.inputs))

class Tanh(Activation):
    def __init__(self):
        super().__init__(lambda x: np.tanh(x),lambda y: 1.0 - (np.tanh(y) ** 2))

class ReLU(Activation):
    def __init__(self):
        super().__init__(lambda x: np.maximum(0,x),lambda y: np.where(y > 0,1,0))

class Sigmoid(Activation):
    def __init__(self):
        super().__init__(lambda x: 1.0 / (1 + np.exp(-x)),lambda y: (1.0 / (1 + np.exp(-y))) * (1 - (1.0 / (1 + np.exp(-y)))))

def mse(y_pred,y_true):
    return np.power(y_true - y_pred,2)

def mse_prime(y_pred,y_true):
    return 2 * (y_pred - y_true)

def run(nn,inputs):
    out = inputs
    for layer in nn:
        out = layer.forward(out)
    return out

这是主要的

if __name__ == '__main__':
    X = np.reshape([[0.1,0.2],[0.5,0.3],[0.2,0.4],[0.3,0.7],0.5],[0.4,0.3]],(6,2,1))
    Y = np.reshape([[0.3],[0.8],[0.6],[1.0],[0.7]],1))

    epochs,learning_rate = 5000,0.01

    network = [
        Dense(2,4),ReLU(),Dense(4,1),ReLU()
    ]

    for _ in range(epochs):
        epoch_error = 0
        for x,y in zip(X,Y):
            output = run(network,x)
            epoch_error += mse(output,y)
            output_gradient = mse_prime(output,y)
            for layer in reversed(network):
                output_gradient = layer.backward(output_gradient,learning_rate)
        epoch_error /= len(X)
        print("%d/%d,error = %f" % (_,epochs,epoch_error))

    test = np.reshape([0.1,(2,1))

    pred = run(network,test)

    print("Prediction = %f" % pred[0][0])

我有两个问题：-

1. 当使用学习率 = 0.1 的 ReLU 以外的激活时，它会接管 100,000 epochs 得到一些接近于零的错误但仍然没有达到 0 但 它是一致的，错误总是在下降，所以第一个问题为什么 解决像添加两个这样简单的任务需要太多的 epoch 使用 Sigmoid 或 Tanh 时的数字？

2. 当使用 ReLU 时，错误可能会非常快地变为 0，大约 5000 个 epoch 但问题是这不一致，有时错误永远不会 下降了，那为什么会发生（我认为问题出在体重上 初始化，但我不确定）以及为什么当它起作用时它会使 与使用其他激活时相比，错误快速变为 0 功能。

解决方法

1. 由于消失，损失不会精确到零 梯度问题。
2. 有时错误永远不会减少，因为权重 达到了局部最小值，这是梯度经常面临的问题 下降算法。尝试使用 SGD（随机梯度下降），其中 有动量可以避免陷入局部最小值并解决问题 问题。