BP网络之C#实现

最新推荐文章于 2022-09-18 12:09:49 发布
最新推荐文章于 2022-09-18 12:09:49 发布
阅读量4.4k 收藏 7
点赞数 1
分类专栏： .net 文章标签： 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

 

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();
    }
  }
}

qw_study
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C#实现的基于BP神经网络的数据预测（降雨量+铁矿石进口量预测）（有界面）
05-09
使用BP神经网络对样本数据（某水库年降雨量监测数据 + 中国铁矿石年进口量监测数据）进行操作，生成需要的训练数据和测试数据。并使用这些数据进行训练处误差小于指定要求的网络，之后可根据界面获取需要预测的年限，并最终进行预测
手搓西瓜书bp神经网络 mnist10 c#版本
UE4引擎技术分享
05-20 1181
本文根据西瓜书第五章中给出的公式编写，书中给出了全连接神经网络的实现逻辑，本文在此基础上编写了Mnist10手写10个数字的案例，网上也有一些其他手搓的例子参考。demo并没有用UE而是使用unity进行编写，方便且易于查错。
敲开bp神经网络之门（二，mfcc中使用，c#）
ganggangwawa的博客
02-11 570
写了186篇博客，刚好，家里门牌号186，所以在家里停留很久，现在又出发...... 看到一篇bpnet好文章，有一种代码实现的冲动，还是先捋一遍，再代码化： 总误差由0.2983降到0.2910，迭代10000次后，输出o1，o2=0.0159,0.984；总误差0.000035085，说明已经收敛到【0.01,0.99】，bpnet学习结束。 我们实现以上过程，进行了简化，少了一个输出，多了两个输入： 为什么步长要取0.5？这个步长在机器学习中（人工智
bp神经网络预测模型实例,BP神经网络预测模型
aifamao6的博客
09-18 1362
图4.2 BP神经网络程序框图（3）网络训练及检验BP网络采用梯度下降法来降低网络的训练误差，考虑到基坑降水地面沉降范围内沉降量变化幅度较小的特点，训练时以训练目标取0.001为控制条件，考虑到网络的结构比较复杂，神经元个数比较多，需要适当增加训练次数和学习速率，因此初始训练次数设为10000次，学习速率取0.1，中间层的神经元传递函数采用S型正切函数tansig，传输函数采用logsig，训练函数采用trainlm，选用38组数据中的33组作为训练样本，5组作为检验样本。，Ym）T的非线性映射。
C#实现的bp神经网络并应用于综合评价
LanQiuChaoRen的专栏
07-13 6969
由于课程设计选的题目是基于神经网络的综合评价，利用暑假时间用C#实现的bp神经网络。此bp神经网络包含1个隐藏层，其中输入层，隐藏层，输出层个数都可以根据需要直接更改。
c# bp神经网络源码
02-17
bp神经网络源码，一层隐含层。经过测试，可以使用。
c# Bp神经网络
great_name的博客
06-14 3876
使用了周志华老师写的机器学习中的神经网络的公式，具体公式可以看《机器学习》--周志华第103页，用的时标准BP算法 具体代码在下面，注释明确 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using ...
C# BP神经网络 类与实例
TJT999
07-11 7912
类：using System; using System.IO; using System.Text; namespace BpANNet { /// /// BpNet 的摘要说明。 /// public class BpNe
一个21行C#代码实现的神经网络
liaogaobo2008的博客
12-16 9815
网上有个经典教程：叫【一个 11行 Python 代码实现的神经网络】，闲来无聊， 我们不用任何第三方的库，全部用C#实现它，我花1天时间写的，主代码也不超过20行（自己写的矩阵类肯定不算再内啦）收敛效果是非常好！希望和大家一起研究学习。 原文链接：http://python.jobbole.com/82758主代码如下： double[,] X = new double[4, 3] { {
C# BP神经网络
似水流年
08-05 2923
using System;  namespace KarstModel  {  ///   /// BP3Layer 的摘要说明。  ///   public class BP3Layer:IModel  {  public BP3Layer()  {  //  // TODO: 在此处添加构造函数逻辑  //  }   //private int nargOut=6;
C#实现BP神经网络算法
11-19
C#实现BP神经网络算法，可以实现训练、泛化，自己设定动量因子和学习速率，还可以实现动态绘制相对误差图
基于C#的BP神经网络算法
12-16
这是在C#平台上编写的神经网络程序，有界面，仅供参考，不足之处请多多指教。
BP神经网络C#算法实现
12-07
Bp神经网络算法C#代码实现。6-18-1模式。6个输入，18个隐层，1个输出。
BP神经网络应用C#程序(好用)
08-18
BP神经网络应用C#程序
C#实现BP神经网络并应用于综合评价
07-13
由于课程设计选的题目是基于神经网络的综合评价，利用暑假时间用C#实现的bp神经网络。此bp神经网络包含1个隐藏层，其中输入层，隐藏层，输出层个数都可以根据需要更改。 详细分析可见：http://blog.csdn.net/lanqiuchaoren/article/details/37738665
bp算法（使用c＃编写）
12-26
bp算法，使用c＃编写，发上来大家共同学习。可以看看。～～～～～～～～～～
C#编写的BP神经网络代码
01-29
C#开发的BP神经网络代码，有多种传递函数和训练方式
NeuralNetwork.NET：受TensorFlow启发的神经网络库，它是在C＃7.3中为.NET Standard 2.0从零开始构建的，并通过cuDNN支持GPU
02-05
它是什么？ NeuralNetwork.NET是一个.NET Standard 2.0库，它实现了具有可自定义层的顺序图和计算图神经网络，并使用C＃从头开始构建。 它提供了一些简单的API，这些API设计用于快速原型设计，以使用随机梯度下降法定义和训练模型，以及保存/加载网络模型及其元数据等的方法。 该库还公开了具有更高级功能的CUDA加速层，这些功能利用GPU和cuDNN工具包极大地提高了训练或使用神经网络时的性能。 免责声明：此库按原样提供，不再被积极维护。 NeuralNetwork.NET是在大学课程中开发的，并不意味着可以替代其他知名的机器学习框架。 如果您正在寻找用于.NET的
bp神经网络 c# 源码
最新发布
11-02
BP神经网络通过训练样本来调整网络中的权值和偏置，从而实现对输入样本的映射。其中，反向传播算法是该模型的核心算法。反向传播算法使用误差函数来度量实际输出与期望输出之间的差异，然后通过链式规则将误差传播回...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值