Python 我能'；在这个反向传播的实现中没有发现错误吗？

我的数据是4123行输入和输出到异或门。 我想写一个包含三个输入层神经元（第三个是bias）、一个隐藏层和一个输出层的神经网络

这是我的实现

import numpy as np

class TwoLayerNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        """
            input_size:  the number of neurons in the input layer
            hidden_size: the number of neurons in the hidden layer
            output_size: the number of neurons in the output layer
        """
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        self.params = {}
        self.params['W1'] = 0.01 * np.random.randn(input_size, hidden_size)  # FxH
        self.params['b1'] = np.zeros((hidden_size, 1)) # Hx1
        self.params['W2'] = 0.01 * np.random.randn(hidden_size, output_size)  # HxO
        self.params['b2'] = np.zeros((output_size, 1))  # Ox1

        self.optimal_weights = []
        self.errors = {}

    def train(self, X, y, epochs):
        """
            X: input data matrix, NxF
            y: output vector, Nx1

            returns:
               the optimal set of parameters that best minimize the loss function
        """

        W1, b1 = self.params['W1'], self.params['b1']
        W2, b2 = self.params['W2'], self.params['b2']



        for iteration in range(epochs):


            forward_to_hidden = X.dot(W1)  # NxH
            activate_hidden = sigmoid(forward_to_hidden)  # NxH
            forward_to_output = activate_hidden.dot(W2)  # NxO
            output = sigmoid(forward_to_output)  # NxO

            self.errors[iteration] = np.mean(0.5 * (y**2 - output**2))

            output_error = y - output  # NxO

            output_layer_delta = output_error * sigmoidPrime(output)  # NxO
            hidden_layer_error = output_layer_delta.dot(W2.T)  # NxO . OxH = NxH
            hidden_layer_delta = hidden_layer_error * sigmoidPrime(activate_hidden) # NxH

            W1_update = X.T.dot(hidden_layer_delta)  # FxN . NxH = FxH
            W2_update = activate_hidden.T.dot(output_layer_delta)  # HxN . NxO = HxO

            W1 += W1_update
            W2 += W2_update

        self.optimal_weights.append(W1)
        self.optimal_weights.append(W2)


    def predict(self, X):
        W1, W2 = self.optimal_weights[0], self.optimal_weights[1]

        forward = sigmoid(X.dot(W1))  # NxH
        forward = forward.dot(W2)  # NxO
        forward = sigmoid(forward) # NxO

        return forward



def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def sigmoidPrime(x):
    return sigmoid(x) * (1 - sigmoid(x))

我知道这很普通，但那是故意的。我想先了解NN体系结构的最基本形式

现在，我的问题是我的错误图很混乱

神经网络只是停止学习

我的第二个问题是，我的权重增加到了-10000，这导致了溢出，因为sigmoid函数中存在exp

我的第三个问题是，我的输出向量只输出0.5，而不是1或0

import pandas as pd

data = pd.read_csv('xor.csv').sample(frac=1)
X = data.iloc[:, [0, 1]]  # 1st and 2nd cols are the input
X = np.hstack((X, np.ones((data.shape[0], 1))))  # adding the bias 1's
y = data.iloc[:, 2][:, np.newaxis]  # 3rd col is the output

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

nn.train(X_train, y_train, 100)

plt.plot(range(100), [i for i in nn.errors.values()])
plt.show()

---

因此，如果我正确地阅读了您的代码，您的网络指定正确，但缺少一些关键点，以便通过反向传播学习XOR

有趣的是，您的错误说明很奇怪。 我成功了

self.errors[iteration]=np.mean（0.5*（y-输出）**2）

用于可视化。 x轴表示历元，y轴表示误差：

所以发生了什么，反向传播到达一个平台，然后迅速地放大权重。为了减缓权重的膨胀，并让网络有时间重新评估其错误，您可以添加所谓的“学习率”！=1.这解决了其中一个陷阱

另一个是第二个数字：你在更新中点击了振荡行为，程序将永远不会达到最佳状态。为了解决这个问题，你可以故意以“动量”的形式输入一个缺陷。

此外，初始条件对收敛速度很重要，因此需要有足够的时间来克服局部高原：

最后，但肯定不是最不重要的一点，我确实发现了您的规范中的错误，但上述所有内容仍然适用

在你的layer_Delta中，你使用SigmoidTime（sigmoid（forwards）），这是对sigmoid的一个调用太多了

last_update = np.zeros((X.shape[1], W1.shape[1]))
last_update2 = np.zeros((W1.shape[1], W2.shape[1]))
        output_layer_delta = output_error * sigmoidPrime(forward_to_output)  # NxO
        hidden_layer_delta = hidden_layer_error * sigmoidPrime(forward_to_hidden) # NxH

        W1 += 0.001*(W1_update + last_update * 0.5)
        W2 += 0.001*(W2_update + last_update2 * 0.5)
#            W1 = 0.001*W1_update
#            W2 = 0.001*W2_update
        last_update = W1_update.copy()
        last_update2 = W2_update.copy()

---

为我做了最后的把戏。现在，请核实并安抚这个发牢骚的人，他花了大半个晚上和一天的时间来弄清楚这件事

因此，如果我正确地阅读了您的代码，那么您的网络指定正确，但缺少一些关键点，以便通过反向传播学习XOR

有趣的是，您的错误说明很奇怪。 我成功了

self.errors[iteration]=np.mean（0.5*（y-输出）**2）

用于可视化。 x轴表示历元，y轴表示误差：

所以发生了什么，反向传播到达一个平台，然后迅速地放大权重。为了减缓权重的膨胀，并让网络有时间重新评估其错误，您可以添加所谓的“学习率”！=1.这解决了其中一个陷阱

另一个是第二个数字：你在更新中点击了振荡行为，程序将永远不会达到最佳状态。为了解决这个问题，你可以故意以“动量”的形式输入一个缺陷。

此外，初始条件对收敛速度很重要，因此需要有足够的时间来克服局部高原：

最后，但肯定不是最不重要的一点，我确实发现了您的规范中的错误，但上述所有内容仍然适用

在你的layer_Delta中，你使用SigmoidTime（sigmoid（forwards）），这是对sigmoid的一个调用太多了

last_update = np.zeros((X.shape[1], W1.shape[1]))
last_update2 = np.zeros((W1.shape[1], W2.shape[1]))
        output_layer_delta = output_error * sigmoidPrime(forward_to_output)  # NxO
        hidden_layer_delta = hidden_layer_error * sigmoidPrime(forward_to_hidden) # NxH

        W1 += 0.001*(W1_update + last_update * 0.5)
        W2 += 0.001*(W2_update + last_update2 * 0.5)
#            W1 = 0.001*W1_update
#            W2 = 0.001*W2_update
        last_update = W1_update.copy()
        last_update2 = W2_update.copy()

---

为我做了最后的把戏。现在，请核实并安抚这个发牢骚的人，他花了大半个晚上和一天的时间来弄清楚这件事

我试过了。我想两个输出神经元会给一个神经元一个高概率，另一个低概率，那么也许我可以设定阈值。但是我得到的两个神经元的输出都是0.5我甚至不知道两个神经元的输出在技术上是否都是一种概率。嗯…这个网络对于它的其余部分似乎并没有太糟糕的规定。它遗漏了一些有效的反向传播技术，但正如你所说，我复制了你的网络，并在一些mnist数据上测试了它，100个训练周期和81%的准确率，没有问题。我真的认为这与你的输入输出格式有关。我想知道网络本身没有问题已经很好了。：）81% !!! 你在开玩笑。哇，这给我留下了深刻的印象。你可能是对的，这是数据。你能试试这个csv文件吗？我在输入数据中添加了一个偏差列，在输入层添加了一个神经元。试过了。我想两个输出神经元会给一个神经元一个高概率，另一个低概率，那么也许我可以设定阈值。但是我得到的两个神经元的输出都是0.5我甚至不知道两个神经元的输出在技术上是否都是一种概率。嗯…这个网络对于它的其余部分似乎并没有太糟糕的规定。它遗漏了一些有效的反向传播技术，但正如你所说，我复制了你的网络，并在一些mnist数据上测试了它，100个训练周期和81%的准确率，没有问题。我真的认为这与你的输入输出格式有关。我想知道网络本身没有问题已经很好了。：）81% !!! 你在开玩笑。哇，这给我留下了深刻的印象。你可能是对的，这是数据。你能试试这个csv文件吗？我在输入数据中添加了一个偏差列，在输入层中添加了一个神经元。更新的答案，现在应该变强更新的答案，现在应该变强