ReLU inconsistency/randomized 行为

Question

我写了一个简单的 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, error_gradient, 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, error_gradient, 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.5], [0.4, 0.3]], (6, 2, 1))
    Y = np.reshape([[0.3], [0.8], [0.6], [1.0], [1.0], [0.7]], (6, 1, 1))

    epochs, learning_rate = 5000, 0.01

    network = [
        Dense(2, 4),
        ReLU(),
        Dense(4, 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, 0.5], (2, 1))

    pred = run(network, test)

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

我有两个问题：-

当使用 learning_rate = 0.1 的 ReLU 以外的激活时，它将接管 100,000 个纪元得到一些接近于零的错误但仍然没有达到 0 但它是一致的，错误总是在下降，所以首先要问为什么解决像加两个这样简单的任务需要太多的时间使用 Sigmoid 或 Tanh 时的数字 ?
当使用 ReLU 时，误差可以非常快地变为 0，大约 5000 轮但问题是这不一致，有时错误永远不会下降，为什么会这样（我认为问题在于重量初始化但我不确定）以及为什么当它工作时它使与使用其他激活相比，错误快速变为 0 函数。

Answer 1

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

ReLU inconsistency/randomized 行为

ReLU inconsistency/randomized behaviour

python

machine-learning

neural-network

activation-function

relu