如何正确实现反向传播算法

Question

我一直在尝试实现自己的玩具神经网络库来进行学习。我已经尝试在逻辑门操作如或门（Or）、与门（And）和异或门（XOR）上对其进行测试。

虽然它可以正常地处理或门操作，但在处理与门和异或门操作时失败了。它很少能够正确输出与门和异或门操作的结果。

我已经尝试过不同范围的学习率，并尝试了不同的学习曲线来找到随着时代数成本模式的变化。

import numpy as np

class myNeuralNet:

    def __init__(self, layers = [2, 2, 1], learningRate = 0.09):
        self.layers = layers
        self.learningRate = learningRate
        self.biasses = [np.random.randn(l, 1)  for l in self.layers[1:]]
        self.weights = [np.random.randn(i, o)  for o, i in zip(self.layers[:-1], self.layers[1:])]
        self.cost = []

    def sigmoid(self, z):
        return (1.0 / (1.0 + np.exp(-z)))

    def sigmoidPrime(self, z):
        return (self.sigmoid(z) * (1 - self.sigmoid(z)))



    def feedForward(self, z, predict = False):
        activations = [z]
        for w, b in zip(self.weights, self.biasses): activations.append(self.sigmoid(np.dot(w, activations[-1]) + b))
        # for activation in activations: print(activation)
        if predict: return np.round(activations[-1])
        return np.array(activations)

    def drawLearningRate(self):
        import matplotlib.pyplot as plt
        plt.xlim(0, len(self.cost))
        plt.ylim(0, 5)
        plt.plot(np.array(self.cost).reshape(-1, 1))
        plt.show()



    def backPropogate(self, x, y):
        bigDW = [np.zeros(w.shape) for w in self.weights]
        bigDB = [np.zeros(b.shape) for b in self.biasses]
        activations = self.feedForward(x)
        delta = activations[-1] - y
        # print(activations[-1])
        # quit()
        self.cost.append(np.sum([- y * np.log(activations[-1]) - (1 - y) * np.log(1 - activations[-1])]))
        for l in range(2, len(self.layers) + 1):
            bigDW[-l + 1] = (1 / len(x)) * np.dot(delta, activations[-l].T)
            bigDB[-l + 1] = (1 / len(x)) * np.sum(delta, axis = 1)
            delta = np.dot(self.weights[-l + 1].T, delta) * self.sigmoidPrime(activations[-l]) 

        for w, dw in zip(self.weights, bigDW): w -= self.learningRate * dw
        for b, db in zip(self.biasses, bigDB): b -= self.learningRate *db.reshape(-1, 1)
        return np.sum(- y * np.log(activations[-1]) - (1 - y) * np.log(1 - activations[-1])) / 2



if __name__ == '__main__':
    nn = myNeuralNet(layers = [2, 2, 1], learningRate = 0.35)
    datasetX = np.array([[1, 1], [0, 1], [1, 0], [0, 0]]).transpose()
    datasetY = np.array([[x ^ y] for x, y in datasetX.T]).reshape(1, -1)
    print(datasetY)
    # print(nn.feedForward(datasetX, predict = True))
    for _ in range(60000): nn.backPropogate(datasetX, datasetY)
    # print(nn.cost)
    print(nn.feedForward(datasetX, predict = True))
    nn.drawLearningRate()

有时会出现“RuntimeWarning: overflow encountered in exp”的警告，有时会导致收敛失败。

- Indi_var

Answer 1

我在从头开始制作神经网络时遇到了同样的问题。我通过使用 scipy.special.expit(x) 而不是np.exp(x)来解决它。如果这对你有用，请告诉我！

- ウィエム

Answer 2

对于交叉熵误差，您需要在网络上具有概率输出层才能正确工作。Sigmoid通常不起作用，也不应该被使用。

您的公式似乎有点问题。对于您定义的当前网络布局：3层（2、2、1），您有w0（2x2）和w1（1x2）。记得找到dw1，您需要以下内容：

  d1 = (guess - target) * sigmoid_prime(net_inputs[1]) <- when you differentiated da2/dz1 you ended up f'(z1) and not f'(a2)!
  dw1 = d1 * activations[1]
  db1 = np.sum(d1, axis=1)
  d0 = d1 * w1 * sigmoid_prime(net_inputs[0])
  dw0 = d0 * activations[0]
  db0 = np.sum(d0, axis=1)

需要记住的是每个层都有net_inputs：

z := w @ x + b

和激活函数：

a := f(z)

。在反向传播时，当计算da[i]/dz[i-1]时，需要将激活函数的导数应用于z[i-1]而不是a[i]。

z = w @ x + b

a = f(z)

da/dz = f'(z) !!!

这适用于所有层。还有一些要注意的细节：

• 如果您的输出层没有使用软/硬最大激活函数（对于单个输出神经元，为什么要使用？），请将错误计算切换为：np.mean(.5 * (activations[-1] - y) ** 2)。

• 在 delta 计算中，使用激活函数的导数时，请使用 z-s。

• 不要使用 Sigmoid（在消失梯度方面存在问题），尝试 ReLu: np.where(x <= 0, 0, x)/np.where(x<=0, 0, 1) 或其某些变体。

• 对于 XOR 的学习率，请选择 [.0001, .1] 之间的值，使用任何优化方式都应该足够。

• 如果您将权重矩阵初始化为 [number_of_input_units x number_of_output_units] 而不是现在的 [number_of_output_units x number_of_input_units]，则可以将 z = w @ x + b 更改为 z = x @ w + b，这样您就不需要转置输入和输出了。

以下是上述内容的示例实现：

import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)


def cost(guess, target):
    return np.mean(np.sum(.5 * (guess - target)**2, axis=1), axis=0)


datasetX = np.array([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
datasetY = np.array([[0.], [1.], [1.], [0.]])


w0 = np.random.normal(0., 1., size=(2, 4))
w1 = np.random.normal(0., 1., size=(4, 1))
b0 = np.zeros(4)
b1 = np.zeros(1)

f1 = lambda x: np.where(x <= 0, 0, x)
df1 = lambda d: np.where(d <= 0, 0, 1)
f2 = lambda x: np.where(x <= 0, .1*x, x)
df2 = lambda d: np.where(d <= 0, .1, 1)


costs = []
for i in range(250):
    a0 = datasetX
    z0 = a0 @ w0 + b0
    a1 = f1(z0)
    z1 = a1 @ w1 + b1
    a2 = f2(z1)
    costs.append(cost(a2, datasetY))

    d1 = (a2 - datasetY) * df2(z1)
    d0 = d1 @ w1.T * df1(z0)

    dw1 = a1.T @ d1
    db1 = np.sum(d1, axis=0)
    dw0 = a0.T @ d0
    db0 = np.sum(d0, axis=0)

    w0 = w0 - .1 * dw0
    b0 = b0 - .1 * db0
    w1 = w1 - .1 * dw1
    b1 = b1 - .1 * db1

print(f2(f1(datasetX @ w0 + b0) @ w1 + b1))

plt.plot(costs)
plt.show()

它所给出的结果：

[[0.00342399]
 [0.99856158]
 [0.99983358]
 [0.00156524]]

- Display name