C#实现BP神经网络，进行数据预测，代码有bug，求找bug。。。

[casen_xu]

麻烦各位高手给看看我这三层的BP伸网络有什么问题，为何训练后，进行预测，预测的结果完全不正确。
网络为三层，输入层有8个节点，输入层只有1个节点，隐含层节点数可以自己设定。
下面是我写的网络训练部分的测试demo。麻烦各位高手给看看哪里出问题了。
[code=csharp][/

b1 = new double[_bp.jiedian]; //隐含层阈值
H_Input = new double[_bp.jiedian]; //隐含层输入输出量
H_Output = new double[_bp.jiedian];
O_Input = new double[_bp.jiedian]; //输出层输入输出量
O_Output = new double[COUT];
double[] E = new double[COUT]; //样本误差
double E_all = 0; //总体误差
double[,] Change_w1 = new double[IN_COUT, _bp.jiedian]; //权矩阵修改量
double[] Change_w2 = new double[_bp.jiedian];
double[] b1_change = new double[_bp.jiedian]; //阈值修改量
double b2_change;
int LoopCout = _bp.loopCout; //最大循环次数

///训练输入量
randomPic = new double[,]{
{0.1, 0.1, 0.2, 0.01, 1, 0.1, 1, 0.01},
{0.2,0.1,0.2,0.01,1,0.1,1,0.01},
{0.3,0.1,0.2,0.01,1,0.1,1,0.01},
{0.1,0.1,0.5,1,0.5,0.1,0.1,0.01},
{0.2,0.1,0.5,1,0.5,0.1,0.1,0.01},
{0.3,0.1,0.5,1,0.5,0.1,0.1,0.01},
{0.1,0.1,1,0.01,1,0.1,0.2,0.1},
{0.2,0.1,1,0.01,1,0.1,0.2,0.1},
{0.3,0.1,1,0.01,1,0.1,0.2,0.1},
{0.1,0.1,0.1,1,0.5,0.1,0.5,0.1}
};
///训练输出的实际期望值
desirePic = new double[]{
0.00559053,
0.00513605,
0.00481229,
0.0131293,
0.0131249,
0.0131248,
0.00640048,
0.00600794,
0.00598705,
0.0139637
};

int n = 0; //统计训练次数
///初始化改变量数组
for (int j = 0; j < IN_COUT; j++)
{
for (int k = 0; k < _bp.jiedian; k++)
{
Change_w1[j, k] = 0;
}
}
for (int j = 0; j < _bp.jiedian; j++)
{
Change_w2[j] = 0;
}

start:
for (int i = 0; i < COUT; i++)
{
///计算隐含层输入向量
for (int k = 0; k < _bp.jiedian; k++)
{
double temp2 = 0;
for (int j = 0; j < IN_COUT; j++)
{
temp2 += W1[j, k] * randomPic[i, j];
}
H_Input[k] = temp2 + b1[k];
}
///计算隐含层输向量
for (int k = 0; k < _bp.jiedian; k++)
{
H_Output[k] = fnet(H_Input[k]);
}
///计算输出层输入向量
for (int k = 0; k < OUT_COUT; k++)
{
double temp1 = 0;
for (int j = 0; j < _bp.jiedian; j++)
{
temp1 += W2[j] * H_Output[j] + b2;
}
O_Input[k] = fnet(temp1);
}
///计算输出层输出向量
for (int k = 0; k < OUT_COUT; k++)
{
O_Output[i] = fnet(O_Input[k]);
}
///第i个样本的输出误差
E[i] = (double)0.5 * (desirePic[i] - O_Output[i]) * (desirePic[i] - O_Output[i]);
///隐含层到输出层的权值调整值
for (int j = 0; j < _bp.jiedian; j++)
{
for (int k = 0; k < OUT_COUT; k++)
{
if (i == 0 || j == 0)
{
Change_w2[j] = _bp.xuexi * (desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]) * H_Output[j];
}
else
{
Change_w2[j] = _bp.xuexi * (1 - _bp.dmoment) * ((desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]) * H_Output[j]) +
_bp.dmoment * ((desirePic[i - 1] - O_Output[i - 1]) * O_Output[i - 1] * (1 - O_Output[i - 1]) * H_Output[j - 1]);
}
}
}
///隐含层到输出层的阈值调整
if (i == 0)
{
b2_change = (desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]) * _bp.xuexi;
}
else
{
b2_change = _bp.xuexi * (1 - _bp.dmoment) * (desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]) +
_bp.dmoment * ((desirePic[i - 1] - O_Output[i - 1]) * O_Output[i - 1] * (1 - O_Output[i - 1]));
}
///输入层到隐含层的权值调整值
for (int j = 0; j < IN_COUT; j++)
{
for (int k = 0; k < _bp.jiedian; k++)
{
Change_w1[j, k] = _bp.xuexi
* randomPic[i, j]
* H_Input[k]
* (1 - H_Output[k])
* (Change_w2[k] * (desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]));
}
}
///输入层到隐含层的阈值调整
for (int j = 0; j < _bp.jiedian; j++)
{
b1_change[j] = _bp.xuexi
* H_Input[j]
* (1 - H_Output[j])
* (Change_w2[j] * (desirePic[i] - O_Output[i]) * O_Output[i] * (1 - O_Output[i]));
}

///调整输入层到隐含层权矩阵
for (int k = 0; k < IN_COUT; k++)
{
for (int j = 0; j < _bp.jiedian; j++)
{
W1[k, j] = W1[k, j] + Change_w1[k, j];
}
}
/// 调整阈值
for (int k = 0; k < _bp.jiedian; k++)
{
b1[k] = b1[k] + b1_change[k];
}
///调整隐含层到输出层权矩阵
for (int k = 0; k < _bp.jiedian; k++)
{
W2[k] = W2[k] + Change_w2[k];
}
///调整阈值
b2 = b2 + b2_change;
///计算总体误差
E_all += E[i];
}
n++;
if (n > LoopCout || (E_all / COUT) < _bp.jingdu)
{
MessageBox.Show("训练完成！");
}
else
{
E_all = 0;
goto start;
}

code]