Question

过去两周我一直在学习反向传播，做了数学背后的考虑并且认为我理解这个主题对于我自己的实现（没有任何线性代数包等）。显然，我错了。下面你可以找到我能想到的最简单的网络示例：2个隐藏单元和1个输出单元。我尝试学习XOR功能。但是，这根本不起作用。预测总是在0.5左右。我不确定我搞砸了哪里。也许有人可以提供帮助？

float sigmoid(float pX) {
    return 1.0f/(1.0f+exp(-1.0f*pX));
}

int main(int argc, char const *argv[]) {
// DEFINE XOR problem
float examples[4][2] = { {0,0} , {0,1}, {1,0}, {1,1}};
float labels[4] = {0, 1, 1, 0};

/* I want to use a network with two hidden neurons and 1 output neuron 
*/

// Weights from input to hidden neurons
float WInput[2][2];
float WInputBias[2];

// Weights from hidden to output neuron
float WOutput[2];
float WOutputBias;

// output of hidden layer to output neuron
float hidden[2];

// error for hidden layer
float error[2];

//output of network 
float yPred;

// randomly init weights
std::random_device rd;
std::mt19937 gen(rd());
std::normal_distribution<float> d(0, 0.1);
WInput[0][0] = d(gen); WInput[0][1] = d(gen); 
WInput[1][0] = d(gen); WInput[1][1] = d(gen); 
WInputBias[0] = d(gen); WInputBias[1] = d(gen);
WOutput[0] = d(gen); WOutput[1] = d(gen); WOutputBias = d(gen);

// do the learning
for(unsigned int i = 0; i < 1000; ++i) {
    for (unsigned int k = 0; k < 4; ++k) {
        float * input = &examples[k][0];
        float label = labels[k];

        // Compute forward pass
        hidden[0] = sigmoid(WInput[0][0]*input[0] + WInput[1][0]*input[1] + WInputBias[0]);
        hidden[1] = sigmoid(WInput[0][1]*input[0] + WInput[1][1]*input[1] + WInputBias[1]);
        yPred = sigmoid(WOutput[0]*hidden[0] + WOutput[1]*hidden[1] + WOutputBias);

        std :: cout << "Target / Prediction: " << label << " / " << yPred << std :: endl;

        // Backward pass with alpha = 0.1
        float outputError = -(label - yPred)*yPred*(1-yPred);
        WOutput[0] = WOutput[0] - 0.1f*outputError*hidden[0]; //hidden equals input from this layer
        WOutput[1] = WOutput[1] - 0.1f*outputError*hidden[1];
        WOutputBias = WOutputBias - 0.1f*outputError;

        error[0] = (WOutput[0]*outputError)*hidden[0]*(1-hidden[0]);
        error[1] = (WOutput[1]*outputError)*hidden[1]*(1-hidden[1]);

        WInput[0][0] = WInput[0][0] - 0.1f*error[0]*input[0];
        WInput[1][0] = WInput[1][0] - 0.1f*error[0]*input[1];
        WInput[0][1] = WInput[0][1] - 0.1f*error[1]*input[0];
        WInput[1][1] = WInput[1][1] - 0.1f*error[1]*input[1];
        WInputBias[0] = WInputBias[0] - 0.1f*error[0];
        WInputBias[1] = WInputBias[1] - 0.1f*error[1];

    }
    std :: cout << std :: endl;
    // getch();
} 
}

Answer 1

我已经看了另外一些代码，并使用了一些参数，结果证明所有代码都是正确的。

问题是，只有2个隐藏节点，这个问题相当难以学习，你使用的时期数（1000）加上你使用的学习率（0.1）只是意味着它还没有收敛。

尝试让它训练大约4000-6000个时期（或者，最好是，直到你的错误的绝对值下降到某个阈值以下），并尝试将重量更新重复1.0而不是0.1。然后你应该得到更好的结果。

将权重随机初始化为[-0.1,0.1]而不是[0.0,0.1]也可能有所帮助。但这不应该产生很大的不同。

反向传播不适用于XOR

1 个答案: