我正在研究前馈反向传播网络并使用＆＃34; Accord.Neuro ＆＃34; c＃中的库（我使用了ResilientBackpropagationLearning类来管理＆＃34;动量＆＃34;本身）。
此时我的问题是要理解如何近似函数，特别是那些是输入变量的线性组合（因此是最简单的函数）。 学习是受监督的，一个例子是：3个变量 - ＆gt; y（x1，x2，x3）= 2 * x1 + x2 + 5 * x3 。
我开始研究单个变量上的函数，然后使用2，然后使用3个变量，我设法获得满意的结果。 我成功地确定了网络的尺寸并获得了良好的效果。
---案例3输入：
在输入变量范围内随机生成的训练集，包含100个示例。 训练1000个时代（但也少）。 我可以得到小于0.001的网络错误，并且验证集上的平均百分比误差为1-2％。
---现在尝试使用4个输入
在输入变量范围内随机生成的训练集，包含500个示例 5000个时代的训练 我可以得到小于2.5的网络错误和25-30％的验证集上的平均百分比错误。
我尝试过这么多配置，结果不佳。即使通过将示例数量增加到5000个，时期最多为100,000个，隐藏节点数量增加到50个，验证集上的平均百分比误差也会提高，但只有20-25％。
为什么我这么差？
这是我的程序的基本代码： http://accord-framework.net/docs/html/T_Accord_Neuro_Learning_ResilientBackpropagationLearning.htm
这是我的简单程序：
using Accord.Neuro;
using Accord.Neuro.Learning;
using System;
namespace ConsoleApp4_1
{
class Program
{
struct struttura
{
public double INPUT1, INPUT2, INPUT3, INPUT4, OUTPUT1;
}
static void Main(string[] args)
{
bool needToStop = false;
Random rr = new Random((int)DateTime.Now.Millisecond);
int NE = 40, epoche = 50000, p;
double ERRORE = 0.00001d;
struttura[] EE = new struttura[NE];
double error = 1;
double[][] input = new double[NE][];
double[][] output = new double[NE][];
for (int u = 0; u < NE; u++) input[u] = new double[4];
for (int u = 0; u < NE; u++) output[u] = new double[1];
for (p = 0; p < NE; p++)
{
EE[p].INPUT1 = rr.Next(1, 200);
EE[p].INPUT2 = rr.Next(1, 100);
EE[p].INPUT3 = rr.Next(1, 50);
EE[p].INPUT4 = rr.Next(1, 150);
EE[p].OUTPUT1 = 0.1d * EE[p].INPUT2 + (2.0d / 3) * EE[p].INPUT1 + (7.0d / 10) * EE[p].INPUT3 + (2.0d / 3) * EE[p].INPUT4; // 278.3333333
}
for (p = 0; p < NE; p++)
{
for (int u = 0; u < NE; u++) input[u][0] = EE[u].INPUT1 / 200;
for (int u = 0; u < NE; u++) input[u][1] = EE[u].INPUT2 / 100;
for (int u = 0; u < NE; u++) input[u][2] = EE[u].INPUT3 / 50;
for (int u = 0; u < NE; u++) input[u][3] = EE[u].INPUT3 / 150;
for (int u = 0; u < NE; u++) output[u][0] = EE[u].OUTPUT1 / 278.3333333;
}
// create neural network
ActivationNetwork network = new ActivationNetwork(new SigmoidFunction(), 4, 8, 1);
// create teacher
var teacher = new ResilientBackpropagationLearning(network);
int i = 0;
// loop
while (!needToStop)
{
i++;
// run epoch of learning procedure
error = teacher.RunEpoch(input, output);
// check error value to see if we need to stop
if ((error < ERRORE) | (i == epoche)) needToStop = true;
Console.WriteLine(i + " " + error);
}
Console.WriteLine("Esempi per epoca: "+NE+" epoca: " + i + " error: " + error + "\n\n"); // bastano 408 epoche con NE = 40
double[] test1 = new double[] { 30.0d / 200, 80.0d / 100, 23.0d / 50, 100.0d/150};
double[] ris1 = network.Compute(test1);
double[] ris1Atteso1 = new double[] { 110.7666667d };
Console.WriteLine("a: " + (ris1[0] * 278.3333333d).ToString("") + " " + ris1Atteso1[0]);
double[] test2 = new double[] { 150.0d / 200, 40.0d / 100, 3.0d / 50, 40.0d/150};
double[] ris2 = network.Compute(test2);
double[] ris1Atteso2 = new double[] { 132.7666667d };
Console.WriteLine("\na: " + (ris2[0] * 278.3333333d).ToString("") + " " + ris1Atteso2[0]);
double[] test3 = new double[] { 15.0d / 200, 30.0d / 100, 45.0d / 50, 146.0d/150};
double[] ris3 = network.Compute(test3);
double[] ris1Atteso3 = new double[] { 141,8333333d };
Console.WriteLine("\na: " + (ris3[0] * 278.3333333d).ToString("") + " " + ris1Atteso3[0]);
double[] test4 = new double[] { 3.0d / 200, 60.0d / 100, 12.0d / 50, 70.0d/150};
double[] ris4 = network.Compute(test4);
double[] ris1Atteso4 = new double[] {63.0666667d};
Console.WriteLine("\na: " + (ris4[0] * 278.3333333d).ToString("") + " " + ris1Atteso4[0]);
double[] test5 = new double[] { 50.0d / 200, 2.0d / 100, 44.0d / 50, 15.0d/150};
double[] ris5 = network.Compute(test5);
double[] ris1Atteso5 = new double[] { 74,333333d };
Console.WriteLine("\na: " + (ris5[0] * 278.3333333d).ToString("") + " " + ris1Atteso5[0]);
double[] test6 = new double[] { 180.0d / 200, 95.0d / 100, 25.0d / 50, 70.0d/150 };
double[] ris6 = network.Compute(test6);
double[] ris1Atteso6 = new double[] { 193.6666667 };
Console.WriteLine("\na: " + (ris6[0] * 278.3333333d).ToString("") + " " + ris1Atteso6[0]);
double[] test7 = new double[] { 22.0d / 200, 12.0d / 100, 2.0d / 50, 10.0d/150 };
double[] ris7 = network.Compute(test7);
double[] ris1Atteso7 = new double[] { 23.9333333d };
Console.WriteLine("\na: " + (ris7[0] * 278.3333333d).ToString("") + " " + ris1Atteso7[0]);
double[] test8 = new double[] { 35.0d / 200, 5.0d / 100, 40.0d / 50, 120.0d/150 };
double[] ris8 = network.Compute(test8);
double[] ris1Atteso8 = new double[] { 131.8333333d };
Console.WriteLine("\na: " + (ris8[0] * 278.3333333d).ToString("") + " " + ris1Atteso8[0]);
double[] test9 = new double[] { 115.0d / 200, 70.0d / 100, 50.0d / 50, 88.0d/150};
double[] ris9 = network.Compute(test9);
double[] ris1Atteso9 = new double[] { 177.3333333d };
Console.WriteLine("\na: " + (ris9[0] * 278.3333333d).ToString("") + " " + ris1Atteso9[0]);
double[] test10 = new double[] { 18.0d / 200, 88.0d / 100, 1.0d / 50, 72.0d/150 };
double[] ris10 = network.Compute(test10);
double[] ris1Atteso10 = new double[] { 69.5d };
Console.WriteLine("\na: " + (ris10[0] * 278.3333333d).ToString("") + " " + ris1Atteso10[0]);
double sum = Math.Abs(ris1[0] * 278.3333333d - ris1Atteso1[0])+ Math.Abs(ris2[0] * 278.3333333d - ris1Atteso2[0]) + Math.Abs(ris3[0] * 278.3333333d - ris1Atteso3[0]) + Math.Abs(ris4[0] * 278.3333333d - ris1Atteso4[0]) + Math.Abs(ris5[0] * 278.3333333d - ris1Atteso5[0])
+ Math.Abs(ris6[0] * 278.3333333d - ris1Atteso6[0]) + Math.Abs(ris7[0] * 278.3333333d - ris1Atteso7[0]) + Math.Abs(ris8[0] * 278.3333333d - ris1Atteso8[0]) + Math.Abs(ris9[0] * 278.3333333d - ris1Atteso9[0]) + Math.Abs(ris10[0] * 278.3333333d - ris1Atteso10[0]);
double erroreMedio = sum / 10;
double sumMedie = Math.Abs((ris1[0] * 278.3333d - ris1Atteso1[0]) / (ris1Atteso1[0]))
+ Math.Abs((ris2[0] * 278.3333d - ris1Atteso2[0]) / (ris1Atteso2[0]))
+ Math.Abs((ris3[0] * 278.3333d - ris1Atteso3[0]) / (ris1Atteso3[0]))
+ Math.Abs((ris4[0] * 278.3333d - ris1Atteso4[0]) / (ris1Atteso4[0]))
+ Math.Abs((ris5[0] * 278.3333d - ris1Atteso5[0]) / (ris1Atteso5[0]))
+ Math.Abs((ris6[0] * 278.3333d - ris1Atteso6[0]) / (ris1Atteso6[0]))
+ Math.Abs((ris7[0] * 278.3333d - ris1Atteso7[0]) / (ris1Atteso7[0]))
+ Math.Abs((ris8[0] * 278.3333d - ris1Atteso8[0]) / (ris1Atteso8[0]))
+ Math.Abs((ris9[0] * 278.3333d - ris1Atteso9[0]) / (ris1Atteso9[0]))
+ Math.Abs((ris10[0] * 278.3333d - ris1Atteso10[0]) / (ris1Atteso10[0]));
Console.WriteLine("\nErrore medio su 10 : "+ erroreMedio);
Console.WriteLine("\nErrore % medio : " + (sumMedie/10)*100);
Console.ReadLine();
}
}
}
答案 0 :(得分：1)
虽然我对Accord不熟悉。 你找到了一个可能发生错误的尺寸网络的经典问题。 神经网络在训练集上得到（极端）好处，但在实际集合上却没有。
我认为你应该用较少隐藏的神经元来尝试它。 当您的网络学习了很多训练集时，导致它无法处理不同的数据。因为获得85％-train和79％-validation会更好。与99％-train和65％-validation相比。请注意，那些％数字表示两个网络的总数百分比相同（85 + 79）=（99 + 65），但第一个网络在解决未知事物方面会更好;这就是总体目标。
现在你所拥有的术语称为过拟合。 最常见的原因是网络开始更像内存，它会记住阈值，而应该更多地关注未知验证集中的决策。嗯，我希望这有帮助。
同时要注意的是，对于较少隐藏的神经元，它也有可能在火车组上达不到100％，但最终它不是解决那个问题，请牢记这一点。
也不确定你尝试用它来解决什么，但要确保你的数据集具有正确的神经网络，对于简单的测试有趣尝试爱尔兰花数据集。我的网络在组合（训练+验证）中的得分可以达到199.16％左右。您可能会尝试击败它，如果是这样，请给我更新:)