我写了一个简单的 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 个 epoch 才能获得接近于零的一些错误，但仍然没有达到 0，但它是一致的并且错误总是下降，所以首先要问为什么它需要太多的 epochs在使用 Sigmoid 或 Tanh 时解决像添加两个数字这样的简单任务？
使用 ReLU 时，错误可能会非常快地变为 0，可能在 5000 个 epoch 左右，但问题是这不一致，有时错误永远不会下降，所以为什么会发生这种情况（我认为问题出在权重初始化但我是不确定）以及为什么与使用其他激活函数时相比，它在工作时会使错误快速变为 0。