前馈反向传播网络使用 c# 逼近线性函数答案

【问题标题】：Feedforward backPropagation networks to approximate linear functions using c#前馈反向传播网络使用 c# 逼近线性函数
【发布时间】：2017-11-11 22:46:26
【问题描述】：

我正在研究 前馈反向传播网络，并在 c# 中使用“Accord.Neuro”库（我使用了 ResilientBackpropagationLearning 类管理“动力”本身）。

此时我的问题是了解如何逼近函数，尤其是那些是输入变量的线性组合的函数（因此是最简单的函数）。学习是有监督的，一个例子是：3 个变量 -> y (x1, x2, x3) = 2 * x1 + x2 + 5 * x3。

我开始研究单个变量的函数，然后是 2 个，然后是 3 个变量，我设法得到了我认为令人满意的结果。我设法确定了网络的尺寸并获得了良好的结果。

---案例3输入：

3 输入
1 个隐藏层，有 15 个节点
1 个输出

在输入变量范围内随机生成的训练集，包含 100 个示例。训练 1000 个 Epoch（但也更少）。我可以得到小于 0.001 的网络错误和 1-2% 的验证集平均百分比错误。

---立即尝试 4 个输入

4 输入
1 个隐藏层，有 25 个节点
1 个输出

训练集，在输入变量范围内随机生成，包含 500 个示例训练 5000 个 Epochs 我可以得到小于 2.5 的网络错误和 25-30% 的验证集的平均百分比错误。

我尝试了很多配置，但结果都很差。即使将示例数量增加到 5000 个，epoch 增加到 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();
        }


    }





}

【问题讨论】：

标签： c# function neural-network backpropagation

【解决方案1】：

虽然我不熟悉雅阁。你试图解决一个可能发生在尺寸错误的网络上的经典问题。神经网络在训练集上（非常）好，但在实际集上却不是。

我认为您应该尝试使用较少隐藏的神经元。随着您的网络对训练集的了解很多，导致它无法处理不同的数据。因为最好获得 85% 的训练和 79% 的验证。与 99% 的训练和 65% 的验证相比。请注意，两个网络的总百分比是相同的（85+79）=（99+65），但是第一个网络在解决未知事物方面会更好；这就是总体目标。

您现在拥有的术语称为过度拟合。最常见的原因是网络开始更像记忆，它记住阈值，而它应该更多地与未知验证集中的决策有关。好吧，我希望这会有所帮助。

还要注意，如果隐藏的神经元较少，也有可能在训练集上无法达到接近 100%，但最终不是为了解决那个问题，请记住这一点。

也不确定您尝试用它解决什么问题，但请确保您的数据集具有正确的神经网络，为了获得简单的测试乐趣，请尝试使用 Irish-flower 数据集。我的网络综合起来（训练+验证）的得分可以达到 199.16% 左右。您可能会尝试击败它，如果是这样，请给我一个更新:)

【讨论】：

按照您的建议，我已经尝试使用更少的神经元以及不同数量的训练集元素和时期。我找不到任何改进
嗯，我不知道你是如何制作训练集和验证集的。但我很好奇你有没有试过交换它们。 ea 你的训练集可以代表你的验证集吗？还是他们之间有很大的区别？也许结合两个数据集，并使用随机生成器随机分为训练集和验证集。如果这没有帮助，请确保您的验证没有问题（不要将测试输入与验证输出进行比较）。（应该是验证输入与验证输出）。
我犯了一个愚蠢、愚蠢的错误 (int u = 0; u
很高兴你找到它，