C# BP神经网络 类与实例

最新推荐文章于 2014-07-13 14:40:59 发布
最新推荐文章于 2014-07-13 14:40:59 发布
阅读量8k 收藏 21
点赞数 3
分类专栏： # C#学习笔记 文章标签： c# 网络 string exception random class

类：

using System;
using System.IO;
using System.Text;
namespace BpANNet
{
    /// <summary>
    /// BpNet 的摘要说明。
    /// </summary>
    public class BpNet
    {
        public int inNum;//输入节点数
        int hideNum;//隐层节点数
        public int outNum;//输出层节点数
        public int sampleNum;//样本总数

        Random R;
        double[] x;//输入节点的输入数据
        double[] x1;//隐层节点的输出
        double[] x2;//输出节点的输出

        double[] o1;//隐层的输入
        double[] o2;//输出层的输入
        public double[,] w;//权值矩阵w
        public double[,] v;//权值矩阵V
        public double[,] dw;//权值矩阵w
        public double[,] dv;//权值矩阵V


        public double rate;//学习率
        public double[] b1;//隐层阈值矩阵
        public double[] b2;//输出层阈值矩阵
        public double[] db1;//隐层阈值矩阵
        public double[] db2;//输出层阈值矩阵

        double[] pp;//输出层的误差
        double[] qq;//隐层的误差
        double[] yd;//输出层的教师数据
        public double e;//均方误差
        double in_rate;//归一化比例系数

        public int computeHideNum(int m, int n)
        {
            double s = Math.Sqrt(0.43 * m * n + 0.12 * n * n + 2.54 * m + 0.77 * n + 0.35) + 0.51;
            int ss = Convert.ToInt32(s);
            return ((s - (double)ss) > 0.5) ? ss + 1 : ss;

        }
        public BpNet(double[,] p, double[,] t)
        {

            // 构造函数逻辑
            R = new Random();

            this.inNum = p.GetLength(1); //数组第二维大小 为 输入节点数
            this.outNum = t.GetLength(1); //输出节点数
            this.hideNum = computeHideNum(inNum, outNum); //隐藏节点数，不知其原理
            //      this.hideNum=18;
            this.sampleNum = p.GetLength(0); //数组第一维大小 为 样本总数

            Console.WriteLine("输入节点数目： " + inNum);
            Console.WriteLine("隐层节点数目：" + hideNum);
            Console.WriteLine("输出层节点数目：" + outNum);

            Console.ReadLine(); //读个空行

            x = new double[inNum];
            x1 = new double[hideNum];
            x2 = new double[outNum];

            o1 = new double[hideNum];
            o2 = new double[outNum];

            w = new double[inNum, hideNum];
            v = new double[hideNum, outNum];
            dw = new double[inNum, hideNum];
            dv = new double[hideNum, outNum];

            b1 = new double[hideNum];
            b2 = new double[outNum];
            db1 = new double[hideNum];
            db2 = new double[outNum];

            pp = new double[hideNum];
            qq = new double[outNum];
            yd = new double[outNum];

            //初始化w
            for (int i = 0; i < inNum; i++)
            {
                for (int j = 0; j < hideNum; j++)
                {
                    w[i, j] = (R.NextDouble() * 2 - 1.0) / 2;
                }
            }

            //初始化v
            for (int i = 0; i < hideNum; i++)
            {
                for (int j = 0; j < outNum; j++)
                {
                    v[i, j] = (R.NextDouble() * 2 - 1.0) / 2;
                }
            }

            rate = 0.8;
            e = 0.0;
            in_rate = 1.0;
        }

        //训练函数
        public void train(double[,] p, double[,] t)
        {
            e = 0.0;
            //求p，t中的最大值
            double pMax = 0.0;
            for (int isamp = 0; isamp < sampleNum; isamp++)
            {
                for (int i = 0; i < inNum; i++)
                {
                    if (Math.Abs(p[isamp, i]) > pMax)
                    {
                        pMax = Math.Abs(p[isamp, i]);
                    }
                }

                for (int j = 0; j < outNum; j++)
                {
                    if (Math.Abs(t[isamp, j]) > pMax)
                    {
                        pMax = Math.Abs(t[isamp, j]);
                    }
                }

                in_rate = pMax;
            }//end isamp



            for (int isamp = 0; isamp < sampleNum; isamp++)
            {
                //数据归一化
                for (int i = 0; i < inNum; i++)
                {
                    x[i] = p[isamp, i] / in_rate;
                }
                for (int i = 0; i < outNum; i++)
                {
                    yd[i] = t[isamp, i] / in_rate;
                }

                //计算隐层的输入和输出

                for (int j = 0; j < hideNum; j++)
                {
                    o1[j] = 0.0;
                    for (int i = 0; i < inNum; i++)
                    {
                        o1[j] += w[i, j] * x[i];
                    }
                    x1[j] = 1.0 / (1.0 + Math.Exp(-o1[j] - b1[j]));
                }

                //计算输出层的输入和输出
                for (int k = 0; k < outNum; k++)
                {
                    o2[k] = 0.0;
                    for (int j = 0; j < hideNum; j++)
                    {
                        o2[k] += v[j, k] * x1[j];
                    }
                    x2[k] = 1.0 / (1.0 + Math.Exp(-o2[k] - b2[k]));
                }

                //计算输出层误差和均方差

                for (int k = 0; k < outNum; k++)
                {
                    qq[k] = (yd[k] - x2[k]) * x2[k] * (1.0 - x2[k]);
                    e += (yd[k] - x2[k]) * (yd[k] - x2[k]);
                    //更新V
                    for (int j = 0; j < hideNum; j++)
                    {
                        v[j, k] += rate * qq[k] * x1[j];
                    }
                }

                //计算隐层误差

                for (int j = 0; j < hideNum; j++)
                {
                    pp[j] = 0.0;
                    for (int k = 0; k < outNum; k++)
                    {
                        pp[j] += qq[k] * v[j, k];
                    }
                    pp[j] = pp[j] * x1[j] * (1 - x1[j]);

                    //更新W

                    for (int i = 0; i < inNum; i++)
                    {
                        w[i, j] += rate * pp[j] * x[i];
                    }
                }

                //更新b2
                for (int k = 0; k < outNum; k++)
                {
                    b2[k] += rate * qq[k];
                }

                //更新b1
                for (int j = 0; j < hideNum; j++)
                {
                    b1[j] += rate * pp[j];
                }

            }//end isamp
            e = Math.Sqrt(e);
            //      adjustWV(w,dw);
            //      adjustWV(v,dv);


        }//end train

        public void adjustWV(double[,] w, double[,] dw)
        {
            for (int i = 0; i < w.GetLength(0); i++)
            {
                for (int j = 0; j < w.GetLength(1); j++)
                {
                    w[i, j] += dw[i, j];
                }
            }

        }

        public void adjustWV(double[] w, double[] dw)
        {
            for (int i = 0; i < w.Length; i++)
            {

                w[i] += dw[i];

            }

        }

        //数据仿真函数

        public double[] sim(double[] psim)
        {
            for (int i = 0; i < inNum; i++)
                x[i] = psim[i] / in_rate;

            for (int j = 0; j < hideNum; j++)
            {
                o1[j] = 0.0;
                for (int i = 0; i < inNum; i++)
                    o1[j] = o1[j] + w[i, j] * x[i];
                x1[j] = 1.0 / (1.0 + Math.Exp(-o1[j] - b1[j]));
            }
            for (int k = 0; k < outNum; k++)
            {
                o2[k] = 0.0;
                for (int j = 0; j < hideNum; j++)
                    o2[k] = o2[k] + v[j, k] * x1[j];
                x2[k] = 1.0 / (1.0 + Math.Exp(-o2[k] - b2[k]));

                x2[k] = in_rate * x2[k];

            }

            return x2;
        } //end sim

        //保存矩阵w,v
        public void saveMatrix(double[,] w, string filename)
        {
            StreamWriter sw = File.CreateText(filename);
            for (int i = 0; i < w.GetLength(0); i++)
            {
                for (int j = 0; j < w.GetLength(1); j++)
                {
                    sw.Write(w[i, j] + " ");
                }
                sw.WriteLine();
            }
            sw.Close();

        }

        //保存矩阵b1,b2
        public void saveMatrix(double[] b, string filename)
        {
            StreamWriter sw = File.CreateText(filename);
            for (int i = 0; i < b.Length; i++)
            {
                sw.Write(b[i] + " ");
            }
            sw.Close();
        }

        //读取矩阵W,V
        public void readMatrixW(double[,] w, string filename)
        {

            StreamReader sr;
            try
            {

                sr = new StreamReader(filename, Encoding.GetEncoding("gb2312"));

                String line;
                int i = 0;

                while ((line = sr.ReadLine()) != null)
                {

                    string[] s1 = line.Trim().Split(' ');
                    for (int j = 0; j < s1.Length; j++)
                    {
                        w[i, j] = Convert.ToDouble(s1[j]);
                    }
                    i++;
                }
                sr.Close();

            }
            catch (Exception e)
            {
                // Let the user know what went wrong.
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }

        }




        //读取矩阵b1,b2
        public void readMatrixB(double[] b, string filename)
        {

            StreamReader sr;
            try
            {
                sr = new StreamReader(filename, Encoding.GetEncoding("gb2312"));

                String line;
                int i = 0;
                while ((line = sr.ReadLine()) != null)
                {
                    b[i] = Convert.ToDouble(line);
                    i++;
                }
                sr.Close();

            }
            catch (Exception e)
            {
                // Let the user know what went wrong.
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }

        }



    }//end bpnet
} //end namespace


主程序：

//主调用程序
using System;

namespace BpANNet
{
    /// <summary>
    /// Class1 的摘要说明。
    /// </summary>
    class Class1
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            //0.1399,0.1467,0.1567,0.1595,0.1588,0.1622,0.1611,0.1615,0.1685,0.1789,0.1790

            //      double [,] p1=new double[,]{{0.05,0.02},{0.09,0.11},{0.12,0.20},{0.15,0.22},{0.20,0.25},{0.75,0.75},{0.80,0.83},{0.82,0.80},{0.90,0.89},{0.95,0.89},{0.09,0.04},{0.1,0.1},{0.14,0.21},{0.18,0.24},{0.22,0.28},{0.77,0.78},{0.79,0.81},{0.84,0.82},{0.94,0.93},{0.98,0.99}};
            //      double [,] t1=new double[,]{{1,0},{1,0},{1,0},{1,0},{1,0},{0,1},{0,1},{0,1},{0,1},{0,1},{1,0},{1,0},{1,0},{1,0},{1,0},{0,1},{0,1},{0,1},{0,1},{0,1}};
            double[,] p1 = new double[,] { { 0.1399, 0.1467, 0.1567, 0.1595, 0.1588, 0.1622 }, { 0.1467, 0.1567, 0.1595, 0.1588, 0.1622, 0.1611 }, { 0.1567, 0.1595, 0.1588, 0.1622, 0.1611, 0.1615 }, { 0.1595, 0.1588, 0.1622, 0.1611, 0.1615, 0.1685 }, { 0.1588, 0.1622, 0.1611, 0.1615, 0.1685, 0.1789 } };
            double[,] t1 = new double[,] { { 0.1622 }, { 0.1611 }, { 0.1615 }, { 0.1685 }, { 0.1789 }, { 0.1790 } };
            BpNet bp = new BpNet(p1, t1);
            int study = 0;
            do
            {
                study++;
                bp.train(p1, t1);
                //       bp.rate=0.95-(0.95-0.3)*study/50000;
                //        Console.Write("第 "+ study+"次学习： ");
                //        Console.WriteLine(" 均方差为 "+bp.e);

            } while (bp.e > 0.001 && study < 50000);
            Console.Write("第 " + study + "次学习： ");
            Console.WriteLine(" 均方差为 " + bp.e);
            bp.saveMatrix(bp.w, "w.txt");
            bp.saveMatrix(bp.v, "v.txt");
            bp.saveMatrix(bp.b1, "b1.txt");
            bp.saveMatrix(bp.b2, "b2.txt");

            //      double [,] p2=new double[,]{{0.05,0.02},{0.09,0.11},{0.12,0.20},{0.15,0.22},{0.20,0.25},{0.75,0.75},{0.80,0.83},{0.82,0.80},{0.90,0.89},{0.95,0.89},{0.09,0.04},{0.1,0.1},{0.14,0.21},{0.18,0.24},{0.22,0.28},{0.77,0.78},{0.79,0.81},{0.84,0.82},{0.94,0.93},{0.98,0.99}};
            double[,] p2 = new double[,] { { 0.1399, 0.1467, 0.1567, 0.1595, 0.1588, 0.1622 }, { 0.1622, 0.1611, 0.1615, 0.1685, 0.1789, 0.1790 } };
            int aa = bp.inNum;
            int bb = bp.outNum;
            int cc = p2.GetLength(0);
            double[] p21 = new double[aa];
            double[] t2 = new double[bb];
            for (int n = 0; n < cc; n++)
            {
                for (int i = 0; i < aa; i++)
                {
                    p21[i] = p2[n, i];
                }
                t2 = bp.sim(p21);

                for (int i = 0; i < t2.Length; i++)
                {
                    Console.WriteLine(t2[i] + " ");
                }

            }

            Console.ReadLine();
        }
    }
}


 

jiutao_tang
关注
专栏目录
c# Bp神经网络
great_name的博客
06-14 4017
使用了周志华老师写的机器学习中的神经网络的公式，具体公式可以看《机器学习》--周志华第103页，用的时标准BP算法 具体代码在下面，注释明确 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using ...
BP神经网络简单应用实例,bp神经网络的设计方法
super67269的博客
08-21 595
这个就是C++与matlab混合编程。但是神经网络工具箱比较特别，它反盗用比较严厉。采用传统的混编方式，可以调用matlab自己的函数，但无法成功调用神经网络工具箱。这一点在mathwork网站上也做了说明。以C#为例，一般混编有四种方式：（1）利用Matlab自身编译器，目的是将m文件转换为c或c++的源代码。（2）利用COM或.NET组件技术。通过MATLAB中的Deploytool工具将m文件编译成dll，然后在系统中调用。（3）利用Mideva平台。没尝试过。（4）利用MATLAB引擎技术。该方法相
C#实现BP神经网络算法
11-19
C#实现BP神经网络算法，可以实现训练、泛化，自己设定动量因子和学习速率，还可以实现动态绘制相对误差图
基于C#的BP神经网络算法
12-16
这是在C#平台上编写的神经网络程序，有界面，仅供参考，不足之处请多多指教。
BP神经网络C#算法实现
12-07
Bp神经网络算法C#代码实现。6-18-1模式。6个输入，18个隐层，1个输出。
C# BP神经网络
似水流年
08-05 2998
using System;  namespace KarstModel  {  ///   /// BP3Layer 的摘要说明。  ///   public class BP3Layer:IModel  {  public BP3Layer()  {  //  // TODO: 在此处添加构造函数逻辑  //  }   //private int nargOut=6;
BP神经网络应用C#程序(好用)
08-18
BP神经网络应用C#程序
BP网络之C#实现
阿伟
02-07 4495
 using System;using System.IO;using System.Text;namespace BpANNet{  ///   /// BpNet 的摘要说明。  ///   public class BpNet  {    public int inNum;//输入节点数    int hideNum;//隐层节点数    public int outNum;//输出层节点数
C#BP神经网络类与实例.pdf
10-02
C#BP神经网络类与实例 本文档主要介绍了C#语言中BP神经网络类的实现和实例，BP神经网络是一种常用的神经网络算法，广泛应用于机器学习、模式识别等领域。本文档中，我们将介绍BP神经网络类的设计和实现细节，并提供...
C#实现BP神经网络并应用于综合评价
01-18
在C#中实现BP神经网络，首先需要创建一个神经元类，包含激活函数（如sigmoid或ReLU）以及权重存储。接着，构建网络结构，定义各层节点数量，并初始化权重。之后，编写前向传播和反向传播的算法，这通常涉及到矩阵...
C#实现的基于BP神经网络的数据预测（降雨量+铁矿石进口量预测）（有界面）
05-09
使用BP神经网络对样本数据（某水库年降雨量监测数据 + 中国铁矿石年进口量监测数据）进行操作，生成需要的训练数据和测试数据。并使用这些数据进行训练处误差小于指定要求的网络，之后可根据界面获取需要预测的年限，并最终进行预测
C#实现神经网络
10-31
改程序能很好地实现神经网络，实现效果好，速度快，能运行
C#编写的BP神经网络代码
01-29
C#开发的BP神经网络代码，有多种传递函数和训练方式
神经网络实例(C#写的算法)(无代码)
12-25
基本的神经网络算法实例，是用C＃编写的，有demo，神经网络的目前最好的示例C＃
C#实现BP神经网络数字图像识别源码
05-03
在C#中实现BP神经网络，通常会用到矩阵运算库，如Math.NET Numerics或Accord.NET，这些库提供了高效的数值计算和机器学习功能。 1. **网络结构**：首先，我们需要定义网络的结构，包括输入节点的数量（对应图像特征...
简单实用，方便利用，实现了BP神经网络在C#下的编程和学习.zip
最新发布
05-19
首先，BP神经网络的核心思想是通过反向传播误差来更新网络权重，以最小化预测输出与实际目标之间的差异。在C#中，你可以使用.NET Framework或.NET Core平台进行开发，这两种框架都提供了丰富的数学库支持，如System....
BP网络模型的实现(C#)
sghgcn的专栏
08-21 1713
最近几天又学了C#,是一次比较系统的接触面向对象,现在对他的理解还不是很深入.所以神经网络模型这几天没怎么看,所以今天就C#来实现一下BP网络模型,一举两得.一些东西看起来挺简单的,但最后实现起来还不是那么简单.特别是C#,因为是第一次接触,所以一些语法性的东西经常用着用着就混淆起来了.不过总的来说还可以.总算是把一个网络模型给实现了.因为对面向对象的思想的理解还有待提高,所以这次只用到了封装
C#实现的bp神经网络并应用于综合评价
LanQiuChaoRen的专栏
07-13 7081
由于课程设计选的题目是基于神经网络的综合评价，利用暑假时间用C#实现的bp神经网络。此bp神经网络包含1个隐藏层，其中输入层，隐藏层，输出层个数都可以根据需要直接更改。
用C#编写BP神经网络
01-03
使用C#编写BP神经网络可以借助一些开源的计算图框架，例如引用中提到的计算图框架。这些框架提供了丰富的功能和示例，可以帮助我们快速构建和训练BP神经网络。 以下是一个使用C#编写BP神经网络的简单示例： ```csharp using System; using Accord.Neuro; using Accord.Neuro.Learning; class Program { static void Main() { // 创建一个BP神经网络 ActivationNetwork network = new ActivationNetwork( new SigmoidFunction(), // 激活函数 2, // 输入层神经元数量 2, // 隐藏层神经元数量 1 // 输出层神经元数量 ); // 创建训练数据 double[][] inputs = { new double[] { 0, 0 }, new double[] { 0, 1 }, new double[] { 1, 0 }, new double[] { 1, 1 } }; double[][] outputs = { new double[] { 0 }, new double[] { 1 }, new double[] { 1 }, new double[] { 0 } }; // 创建BP神经网络的学习算法 BackPropagationLearning teacher = new BackPropagationLearning(network); // 训练神经网络 double error = 1; int epoch = 0; while (error > 0.001 && epoch < 10000) { error = teacher.RunEpoch(inputs, outputs); epoch++; } // 使用训练好的神经网络进行预测 double[] input = { 0, 1 }; double[] output = network.Compute(input); Console.WriteLine("Input: {0}, Output: {1}", string.Join(", ", input), output[0]); } } ``` 这个示例使用Accord.NET库中的`ActivationNetwork`类和`BackPropagationLearning`类来构建和训练BP神经网络。首先，我们创建了一个具有2个输入神经元、2个隐藏神经元和1个输出神经元的神经网络。然后，我们定义了训练数据，包括输入和期望输出。接下来，我们创建了一个`BackPropagationLearning`对象，它将用于训练神经网络。在训练过程中，我们使用`RunEpoch`方法迭代训练数据，直到达到指定的误差或迭代次数。最后，我们使用训练好的神经网络对新的输入进行预测，并输出结果。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值