C++ 我找不到调整神经网络的正确方法

我想输入3个数字，可以是1.0或0.0，然后用神经网络根据我的数组预测输出。我找不到问题所在，我尝试了很多东西，但都没有成功。我改变了学习速度和一些功能，但这让情况变得更糟。这是错误最少的代码。提前谢谢你的帮助

#include <iostream>
#include <math.h>
#include <time.h>

以下是变量

int x=0;
double a, m, c,k;
double w1;
double w2;
double w3;
double w4;
double w5;
double w6;
double w7;
double w8;
double b1;
double b2;
double b3;
double target;
double z1;
double z2;
double ze;
double pred1;
double pred2;
double prede;
double cost1;
double cost2;
double coste;
double dcost_dpred1, dcost_dpred2, dcost_dprede;
double dpred_dz1, dpred_dz2,dpred_dze;
double dz_dw1, dz_dw2, dz_dw3, dz_dw4, dz_dw5, dz_dw6, dz_dw7, dz_dw8;
double dz_db1,dz_db2, dz_db3;
double dcost_dw1, dcost_dw2, dcost_dw3, dcost_dw4, dcost_dw5, dcost_dw6, 
dcost_dw7, dcost_dw8;
double dcost_db1, dcost_db2,dcost_db3;
double learning_rate = 0.1;
double a1[8][4] = { 0.0, 0.0, 0.0, 1.0,
                0.0, 0.0, 1.0, 0.0,
                0.0, 1.0, 0.0, 1.0,
                0.0, 1.0, 1.0, 0.0,
                1.0, 0.0, 0.0, 0.0,
                1.0, 0.0, 1.0, 1.0,
                1.0, 1.0, 0.0, 0.0,
                1.0, 1.0, 1.0, 1.0 };//The first 3 numbers in each row are the inputs and the target is the fourth.

权重和偏差初始化

srand(time(NULL));
w1= randfrom(0.1, 0.9);
w2 = randfrom(0.1, 0.9);
w3 = randfrom(0.1, 0.9);
w4 = randfrom(0.1, 0.9);
w5 = randfrom(0.1, 0.9);
w6 = randfrom(0.1, 0.9);
w7 = randfrom(0.1, 0.9);
w8 = randfrom(0.1, 0.9);
b1 = randfrom(0.1, 0.9);
b2 = randfrom(0.1, 0.9);
b3 = randfrom(0.1, 0.9);

这是训练循环

for (int i = 0; i < 500000; i++) {
    target = a1[x][3];
    z1 = w1 * a1[x][0] + w3 * a1[x][1] + w5 * a1[x][2] + b1;
    z2 = w2 * a1[x][0] + w4 * a1[x][1] + w6 * a1[x][2] + b2;
    ze = w7 * z1 + w8 * z2 + b3;
    pred1 = sigmoid(z1);
    pred2 = sigmoid(z2);
    prede = sigmoid(ze);
    cost1 = (pred1 - target)*(pred1-target);
    cost2 = (pred2 - target)*(pred2 - target);
    coste = (prede - target)*(prede - target);
    dcost_dpred1 = 2.0 * (pred1 - target);
    dcost_dpred2 = 2.0 * (pred2 - target);
    dcost_dprede = 2.0 * (prede - target);
    dpred_dz1 = sigmoid(z1)*(1 - sigmoid(z1)); 
    dpred_dz2 = sigmoid(z2)*(1 - sigmoid(z2));
    dpred_dze = sigmoid(ze)*(1 - sigmoid(ze));
    dz_dw1 = a1[x][0];
    dz_dw2 = a1[x][0];
    dz_dw3 = a1[x][1];
    dz_dw4 = a1[x][1];
    dz_dw5 = a1[x][2];
    dz_dw6 = a1[x][2];
    dz_dw7 = z1;
    dz_dw8 = z2;
    dz_db1 = 1.0;
    dz_db2 = 1.0;
    dz_db3 = 1.0;
    dcost_dw1 = dcost_dpred1 * dpred_dz1 * dz_dw1;
    dcost_dw2 = dcost_dpred2 * dpred_dz2 * dz_dw2;
    dcost_dw3 = dcost_dpred1 * dpred_dz1 * dz_dw3;
    dcost_dw4 = dcost_dpred2 * dpred_dz2 * dz_dw4;
    dcost_dw5 = dcost_dpred1 * dpred_dz1 * dz_dw5;
    dcost_dw6 = dcost_dpred2 * dpred_dz2 * dz_dw6;
    dcost_dw7 = dcost_dprede * dpred_dze * dz_dw7;
    dcost_dw8 = dcost_dprede * dpred_dze * dz_dw8;
    dcost_db1 = dcost_dpred1 * dpred_dz1 * dz_db1;
    dcost_db2 = dcost_dpred2 * dpred_dz2 * dz_db2;
    dcost_db3 = dcost_dprede * dpred_dze * dz_db3;

    w1 += learning_rate * dcost_dw1;
    w2 += learning_rate * dcost_dw2;
    w3 += learning_rate * dcost_dw3;
    w4 += learning_rate * dcost_dw4;
    w5 += learning_rate * dcost_dw5;
    w6 += learning_rate * dcost_dw6;
    w7 += learning_rate * dcost_dw7;
    w8 += learning_rate * dcost_dw8;
    b1 += learning_rate * dcost_db1;
    b2 += learning_rate * dcost_db2;
    b3 += learning_rate * dcost_db3;
    if (x < 7) 
    {
        x++;
    }
    else if (x == 7)
    {
        x = 0;
    }
}

for（int i=0；i<500000；i++）{
目标=a1[x][3]；
z1=w1*a1[x][0]+w3*a1[x][1]+w5*a1[x][2]+b1；
z2=w2*a1[x][0]+w4*a1[x][1]+w6*a1[x][2]+b2；
ze=w7*z1+w8*z2+b3；
pred1=乙状结肠（z1）；
pred2=乙状结肠（z2）；
prede=乙状结肠（ze）；
成本1=（pred1-目标）*（pred1目标）；
成本2=（pred2-目标）*（pred2-目标）；
成本=（预定目标）*（预定目标）；
dcost_dpred1=2.0*（pred1-目标）；
dcost_dpred2=2.0*（pred2-目标）；
dcost_dprede=2.0*（预测目标）；
dpred_dz1=sigmoid（z1）*（1-sigmoid（z1））；
dpred_dz2=sigmoid（z2）*（1-sigmoid（z2））；
朝鲜天皇=乙状结肠（ze）*（1-乙状结肠（ze））；
dz_dw1=a1[x][0]；
dz_dw2=a1[x][0]；
dz_dw3=a1[x][1]；
dz_dw4=a1[x][1]；
dz_dw5=a1[x][2]；
dz_dw6=a1[x][2]；
dz_dw7=z1；
dz_dw8=z2；
dz_db1=1.0；
dz_db2=1.0；
dz_db3=1.0；
dcost_dw1=dcost_dpred1*dpred_dz1*dz_dw1；
dcost_dw2=dcost_dpred2*dpred_dz2*dz_dw2；
dcost_dw3=dcost_dpred1*dpred_dz1*dz_dw3；
dcost_dw4=dcost_dpred2*dpred_dz2*dz_dw4；
dcost_dw5=dcost_dpred1*dpred_dz1*dz_dw5；
dcost_dw6=dcost_dpred2*dpred_dz2*dz_dw6；
dcost_dw7=dcost_dprede*dpred_dze*dz_dw7；
dcost_dw8=dcost_dprede*dpred_dze*dz_dw8；
dcost_db1=dcost_dpred1*dpred_dz1*dz_db1；
dcost_db2=dcost_dpred2*dpred_dz2*dz_db2；
dcost_db3=dcost_dprede*dpred_dze*dz_db3；
w1+=学习率*成本dw1；
w2+=学习率*dcost\u dw2；
w3+=学习率*dcost\u dw3；
w4+=学习率*dcost\u dw4；
w5+=学习率*dcost\u dw5；
w6+=学习率*dcost\u dw6；
w7+=学习率*dcost\u dw7；
w8+=学习率*dcost\u dw8；
b1+=学习率*成本db1；
b2+=学习率*dcost\u db2；
b3+=学习率*dcost\u db3；
if（x<7）
{
x++；
}
else如果（x==7）
{
x=0；
}
}

在这里，我添加输入以查看程序是否有效

double l,j,o;
for (int i = 0; i < 9; i++) {
    std::cout << "Enter first number:";
    std::cin >> a;
    std::cout << std::endl;
    std::cout << "Enter second number:";
    std::cin >> m;
    std::cout << std::endl;
    std::cout << "Enter third number:";
    std::cin >> c;
    std::cout << std::endl;
    l = w1 * a + w3 * m + w5 * c + b1;
    j = w2 * a + w4 * m + w6 * c + b2;
    o = w7 * l + w8 * j + b3;
    std::cout << "The prediction is:" << sigmoid(o)<<std::endl;
}
std::cin >> k;
}

double l，j，o；
对于（int i=0；i<9；i++）{
std：：cout>a；
std：：cout m；
std：：coutc；
通常，乙状结肠等于1/（1+exp（-x））而不是1/（1+exp（x））。
我在您的程序中尝试了这种修改，同时更改了权重更新的符号。但是，我得到了与初始程序大致相同的结果

此外，你想用你的网络建模的公式是“1 xor a[0]xor a[2]”。我对神经网络和xor建模做了一个快速的研究，我发现一个隐藏层是必要的

你试过用一个隐藏层和“经典”的乙状结肠来模拟它吗

我很抱歉没有提出一个真正的解决方案。我想这应该是一个评论

但是，我不允许发表评论。希望这能有所帮助

编辑：我在您的代码中发现了两个其他问题：


在训练循环中，ze的计算应使用pred1（sigmoid（z1））和pred2，而不是z1和z2

同样，在main（）的末尾，对于NN输出的测试，o的计算应使用sigmoid（l）和sigmoid（j），而不是l和j


但是，程序仍然不起作用。程序中隐藏的一个层。请使用预览窗格来验证，您的代码缩进得很好。如果您希望得到我们的帮助，我们期待您的努力。只有格式化在这里无济于事，您应该考虑在多个函数中分解代码以获得更多的ReA。可读取。您的目标是自己实现NN还是使用NN解决问题？如果是第二个，我建议采用现成的NN实现。对于数据、功能和参数的处理，我建议使用KNIME或类似产品（Weka、RapidMiner、Orange）我认为代码现在可读性更强了。我尝试了隐藏层的leaky relu，但它不起作用。我把sigmoid函数弄错了。愚蠢的错误。但正如你所说的，即使我纠正了它，它仍然不能解决问题。感谢你的回答，你帮我指出了我在sigmoid函数上的错误。
double l,j,o;
for (int i = 0; i < 9; i++) {
    std::cout << "Enter first number:";
    std::cin >> a;
    std::cout << std::endl;
    std::cout << "Enter second number:";
    std::cin >> m;
    std::cout << std::endl;
    std::cout << "Enter third number:";
    std::cin >> c;
    std::cout << std::endl;
    l = w1 * a + w3 * m + w5 * c + b1;
    j = w2 * a + w4 * m + w6 * c + b2;
    o = w7 * l + w8 * j + b3;
    std::cout << "The prediction is:" << sigmoid(o)<<std::endl;
}
std::cin >> k;
}