BP神经网络算法（2）

最新推荐文章于 2024-07-14 12:25:25 发布
最新推荐文章于 2024-07-14 12:25:25 发布
阅读量1.9k 收藏 2
点赞数
分类专栏： Algorithm 文章标签： 算法 网络 stream null file qq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaolongwang2010/article/details/7583076
版权

 

//BpNet.h: interface for the Bp class.
// 2006.8.8 by 曾志军 版权所有  
//E-Mail:zengzhijun369@163.com
/**///
#include "stdafx.h"
#include "BpNet.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

/**///
// Construction/Destruction
/**///

BpNet::BpNet()
{       
    error=1.0;
    e=0.0;
    
    rate_w=0.05;  //权值学习率（输入层--隐含层)
    rate_w1=0.047; //权值学习率 (隐含层--输出层)
    rate_b1=0.05; //隐含层阀值学习率
    rate_b2=0.047; //输出层阀值学习率
    error=1.0;
    e=0.0;
    
    rate_w=0.05;  //权值学习率（输入层--隐含层)
    rate_w1=0.047; //权值学习率 (隐含层--输出层)
    rate_b1=0.05; //隐含层阀值学习率
    rate_b2=0.047; //输出层阀值学习率
}

BpNet::~BpNet()
{
    
}

void winit(double w[],int sl)//权值初始化
{int i;
double randx();
for(i=0;i<sl;i++){
    *(w+i)=0.2*randx();
}
}

double randx()//kqy error
{double d;
d=(double) rand()/32767.0;
return d;
}

void BpNet::init()
{
    winit((double*)w,innode*hidenode);
    winit((double*)w1,hidenode*outnode);
    winit(b1,hidenode);
    winit(b2,outnode);
}


void BpNet::train(double p[trainsample][innode],double t[trainsample][outnode])
{
    double pp[hidenode];//隐含结点的校正误差
    double qq[outnode];//希望输出值与实际输出值的偏差
    double yd[outnode];//希望输出值
    
    double x[innode]; //输入向量
    double x1[hidenode];//隐含结点状态值
    double x2[outnode];//输出结点状态值
    double o1[hidenode];//隐含层激活值
    double o2[hidenode];//输出层激活值
    for(int isamp=0;isamp<trainsample;isamp++)//循环训练一次样品
    { 
        for(int i=0;i<innode;i++)
            x[i]=p[isamp][i];
        for(i=0;i<outnode;i++)
            yd[i]=t[isamp][i];
        
        //构造每个样品的输入和输出标准
        for(int j=0;j<hidenode;j++)
        {
            o1[j]=0.0;
            
            for(i=0;i<innode;i++)
                o1[j]=o1[j]+w[i][j]*x[i];//隐含层各单元输入激活值
            x1[j]=1.0/(1+exp(-o1[j]-b1[j]));//隐含层各单元的输出kqy1
            //    if(o1[j]+b1[j]>0) x1[j]=1;
            //else x1[j]=0;
        }
        
        for(int k=0;k<outnode;k++)
        {
            o2[k]=0.0;
            
            for(j=0;j<hidenode;j++)
                o2[k]=o2[k]+w1[j][k]*x1[j];//输出层各单元输入激活值
            x2[k]=1.0/(1.0+exp(-o2[k]-b2[k]));//输出层各单元输出
            //    if(o2[k]+b2[k]>0) x2[k]=1;
            //    else x2[k]=0;
        }
        
        for(k=0;k<outnode;k++)
        {
            e=0.0;
            qq[k]=(yd[k]-x2[k])*x2[k]*(1.-x2[k]);//希望输出与实际输出的偏差
            e+=fabs(yd[k]-x2[k])*fabs(yd[k]-x2[k]);//计算均方差
            
            for(j=0;j<hidenode;j++)
                w1[j][k]=w1[j][k]+rate_w1*qq[k]*x1[j];//下一次的隐含层和输出层之间的新连接权
            e=sqrt(e);
            error=e;
        
        }
        
        for(j=0;j<hidenode;j++)
        {
            pp[j]=0.0;
            for(k=0;k<outnode;k++)
                pp[j]=pp[j]+qq[k]*w1[j][k];
            pp[j]=pp[j]*x1[j]*(1-x1[j]);//隐含层的校正误差
            
            for(i=0;i<innode;i++)
                w[i][j]=w[i][j]+rate_w*pp[j]*x[i];//下一次的输入层和隐含层之间的新连接权
        }
        
        for(k=0;k<outnode;k++)
            b2[k]=b2[k]+rate_b2*qq[k];//下一次的隐含层和输出层之间的新阈值
        for(j=0;j<hidenode;j++)
            b1[j]=b1[j]+rate_b1*pp[j];//下一次的输入层和隐含层之间的新阈值
        
    }//end isamp样品循环
    
}
/**////end train/////

/////

double *BpNet::recognize(double *p)
{   
    double x[innode]; //输入向量
    double x1[hidenode];//隐含结点状态值
    double x2[outnode];//输出结点状态值
    double o1[hidenode];//隐含层激活值
    double o2[hidenode];//输出层激活值

    for(int i=0;i<innode;i++)
        x[i]=p[i];
    for(int j=0;j<hidenode;j++)
    {
        o1[j]=0.0;
        
        for(int i=0;i<innode;i++)
            o1[j]=o1[j]+w[i][j]*x[i];//隐含层各单元激活值
        x1[j]=1.0/(1.0+exp(-o1[j]-b1[j]));//隐含层各单元输出
        //if(o1[j]+b1[j]>0) x1[j]=1;
        //    else x1[j]=0;
    }
    
    for(int k=0;k<outnode;k++)
    {
        o2[k]=0.0;
        for(int j=0;j<hidenode;j++)
            o2[k]=o2[k]+w1[j][k]*x1[j];//输出层各单元激活值
        x2[k]=1.0/(1.0+exp(-o2[k]-b2[k]));//输出层各单元输出
        //if(o2[k]+b2[k]>0) x2[k]=1;
        //else x2[k]=0;
    } 
    
    for(k=0;k<outnode;k++)
    {
        shuchu[k]=x2[k];
    } 
    return shuchu;
}/**/////end sim///

void BpNet::writetrain()
{//曾志军 for 2006.7
    AfxMessageBox("你还没有训练呢，训练后再写吧!请不要乱写,除非你认为这次训练是最好的，否则会覆盖我训练好的权值，那样你又要花时间训练!");
    AfxMessageBox("你认为这次训练结果是最好的，就存下来，下次就不要花时间训练了!",MB_YESNO,NULL);
    FILE *stream0;
    FILE *stream1;
    FILE *stream2;
    FILE *stream3;
    int i,j;
    /**/
    if(( stream0 = fopen("w.txt", "w+" ))==NULL)
    {
        AfxMessageBox("创建文件失败!");
    }
    for(i=0;i<innode;i++)
    {
        for(j=0;j<hidenode;j++)
        {
            
            fprintf(stream0, "%f\n", w[i][j]);
        }
        
    }
    fclose( stream0);
    /**////
    if(( stream1 = fopen("w1.txt", "w+" ))==NULL)
    {
        AfxMessageBox("创建文件失败！");
    }
    for(i=0;i<hidenode;i++)
    {
        for(j=0;j<outnode;j++)
        {
            fprintf(stream1, "%f\n",w1[i][j]);
        }
        
    }
    fclose( stream1);
    /**/////
    if(( stream2 = fopen("b1.txt", "w+" ))==NULL)
    {
        AfxMessageBox("创建文件失败！");
    }
        for(i=0;i<hidenode;i++)
    {
        fprintf(stream2, "%f\n",b1[i]);
        
        
    }
    fclose( stream2);
    /**//
    if(( stream3 = fopen("b2.txt", "w+" ))==NULL)
    {
        AfxMessageBox("创建文件失败！");
    }
    for(i=0;i<outnode;i++)
    {
        fprintf(stream3, "%f\n",b2[i]);
        
        
    }
    fclose( stream3);
    
    
}


void BpNet::readtrain()
{
    //曾志军 for 2006.7
    AfxMessageBox("读入已训练好的权值，这样你就不要花时间训练了!",MB_YESNO,NULL);
    FILE *stream0;
    FILE *stream1;
    FILE *stream2;
    FILE *stream3;
    int i,j;
    /**//////
    if(( stream0 = fopen("w.txt", "r" ))==NULL)
    {
        AfxMessageBox("文件不存在，请先写入权值，再读！");
    }
    
    float  wx[innode][hidenode];
    for(i=0;i<innode;i++)
        for(j=0;j<hidenode;j++)
        {
            fscanf(stream0, "%f", &wx[i][j]);
            w[i][j]=wx[i][j];
        }
    fclose( stream0);
    /**////    
    if(( stream1 = fopen("w1.txt", "r" ))==NULL)
        {
            AfxMessageBox("文件不存在，请先写入权值，再读！");
        }
         float  wx1[hidenode][outnode]; 
        for(i=0;i<hidenode;i++)
        {
            for(j=0;j<outnode;j++)
            {
                fscanf(stream1, "%f", &wx1[i][j]);
                w1[i][j]=wx1[i][j];
            }
            
        }
        fclose( stream1);
        
        /**////
        if(( stream2 = fopen("b1.txt", "r" ))==NULL)
        {
            AfxMessageBox("文件不存在，请先写入权值，再读！");
        }
        float xb1[hidenode];    
        for(i=0;i<hidenode;i++)
        {
            fscanf(stream2, "%f",&xb1[i]);
            b1[i]=xb1[i];
        }
        fclose( stream2);
        /**///
        if(( stream3 = fopen("b2.txt", "r" ))==NULL)
        {
            AfxMessageBox("文件不存在，请先写入权值，再读！");
        }
        float xb2[outnode];  
        for(i=0;i<outnode;i++)
        {
            fscanf(stream3, "%f",&xb2[i]);
            b2[i]=xb2[i];
        }
        
        fclose( stream3);
        /**//*CFile TheFile("w.txt",CFile::modeRead);
        CArchive ar(&TheFile,CArchive::load,40960);
        TheFile.SeekToBegin();
        int i,j;
        for(i=0;i<innode;i++)
        {
        for(j=0;j<hidenode;j++)
        {   
        ar>>w[i][j];
        
          }
          
            }
            ar.Close();
        TheFile.Close();*/
        
}
//BpNet.h: interface for the Bp class.
// 2006.8.8 by 曾志军 版权所有  
//E-Mail:zengzhijun369@163.com
/**///

#if !defined(AFX_BPNET_H__3A171E41_1E8B_11D7_BA67_936006E9954B__INCLUDED_)
#define AFX_BPNET_H__3A171E41_1E8B_11D7_BA67_936006E9954B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#define  innode 5  //输入结点数
#define  hidenode 10//隐含结点数
#define  outnode 4 //输出结点数
#define  trainsample 500//BP训练样本为10个
class BpNet  
{
public:
    void train(double p[trainsample][innode ],double t[trainsample][outnode]);//Bp训练
    //double p[trainsample][innode]     //输入的样本
    //double t[trainsample][outnode]//样本要输出的
    //Bp训练前要调用readtemplate()
    double *recognize(double *p);//Bp识别
    
    void writetrain();//写训练完的权值
    void readtrain();//读训练好的权值，这使的不用每次去训练了，只要把训练最好的权值存下来writetrain()就OK！
    
    BpNet();
    virtual ~BpNet();


public:
    void init();
    double w[innode][hidenode];//隐含结点权值
    double w1[hidenode][outnode];//输出结点权值
    double b1[hidenode];//隐含结点阀值
    double b2[outnode];//输出结点阀值
    
    double rate_w; //权值学习率（输入层-隐含层)
    double rate_w1;//权值学习率 (隐含层-输出层)
    double rate_b1;//隐含层阀值学习率
    double rate_b2;//输出层阀值学习率

    
    double e;//误差计算
    double error;//允许的最大误差
    double shuchu[outnode];// Bp输出
    

};

#endif // !defined(AFX_BPNET_H__3A171E41_1E8B_11D7_BA67_936006E9954B__INCLUDED_)

全文参考：http://www.cnblogs.com/demon521/archive/2008/04/07/1140359.html

 

 

小龙王2010
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
BP神经网络算法
weixin_43998483的博客
09-30 3160
算法介绍 百度百科：BP神经网络算法是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hide layer)和输出层(output...
BP神经网络算法推导
info_kerwin的博客
01-15 915
BP神经网络算法推导 BP算法的基本思想是，学习过程由信号的正向传播与误差的反向传播两个过程组成正向传播时，输人样本从输人层传入，经各隐层逐层处理后，传向输出层。若输出层的实际输出与期望的输出(教师信号)不符，则转入误差的反向传播阶段。误差反传是将输出误差以某种形式通过隐层向输入层逐层反传，并将误差分推给各层的所有单元，从而获得各层单元的误差信号，此误差信号即作为修正各单元权值的依据。这种
BP神经网络
火柴
04-18 142
忘记转载的哪里的了，见谅// ConsoleApplication3.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "atltime.h" #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;fstream&gt; using name...
神经网络——Python实现BP神经网络算法（理论+例子+程序）
Linyun2tt的博客
11-27 7万+
一、基于BP算法的多层感知器模型 采用BP算法的多层感知器是至今为止应用最广泛的神经网络，在多层感知器的应用中，以图3-15所示的单隐层网络的应用最为普遍。一般习惯将单隐层前馈网称为三层感知器，所谓三层包括了输入层、隐层和输出层。 算法最终结果采用梯度下降法，具体详细过程此处就省略了！ 二、BP算法的程序实现流程 三、标准BP算法的改进——增加动量项 标准BP算法在调整权值时，只按t时刻误差的梯度降方向调整，而没有考虑t时刻以前的梯度方向，从而常使训练过程发生振荡，收敛缓慢。为了提
BP神经网络预测matlab代码讲解与实现步骤
热门推荐
CJ-leaf的博客
12-07 21万+
文章目录1. BP神经网络的简介和结构参数1.1 BP神经网络的结构组成1.2 BP神经网络训练界面的参数解读2. 实现BP网络的步骤3. matlab代码编写4. BP代码运行结果4.1 预测值和真实值的误差计算（MAE、MSE、MRSE）4.2 BP网络训练的性能分析图像5. 结语6. MATLAB代码 1. BP神经网络的简介和结构参数 神经网络是机器学习中一种常见的数学模型，通过构建类似于大脑神经突触联接的结构，来进行信息处理。在应用神经网络的过程中，处理信息的单元一般分为三类：输入单元、输出单元和
bp 神经网络算法.zip
10-18
bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法bp 神经网络算法bp 神经网络算法 bp 神经网络算法...
Python实现BP神经网络算法.zip
12-26
Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 Python实现BP神经网络算法Python实现BP神经网络算法 ...
遗传算法优化BP神经网络
11-26
**遗传算法优化BP神经网络** 遗传算法（Genetic Algorithm，GA）是一种模拟自然选择和遗传机制的优化技术，常用于解决复杂问题的全局优化。它通过模拟生物进化过程中的基因组合、选择、交叉和变异等操作，寻找问题...
Bp神经网络算法推导与实现
06-01
以下是BP神经网络算法的基本推导和实现步骤： ### 算法推导 1. **前向传播**： - 输入层到隐藏层的权重调整：`hidden_layer_input = dot_product(input, hidden_weights)` - 隐藏层的激活：`hidden_layer_...
BP神经网络算法（1）
小龙王2010
05-19 7221
BP（Back Propagation）网络是1986年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。 一个神经网络的结构示意图如下所示。 BP神经网络模型拓扑结构包括输入层（input）、隐层(hide
【C语言】求两个整数的最大公约数、最小公倍数
小龙王2010
04-29 7126
分析：求最大公约数的算法思想： 1）对于已知两数m,n，使得m>n; 2）m除以n得余数r; 3）若r=0,则n 为求得的最大公约数，算法结束；否则执行（4）； 4）m 其中，最小公倍数 = 两个整数之积 / 最大公约数 例： 求 m = 14,n=6的最大公约数 和 最小公倍数 m   n   r 14  6   2  6   2   0 /* * main.c *
【C语言】 计数、求和、求阶乘等简单算法
小龙王2010
04-29 3989
计数、求和、求阶乘等简单算法，此类问题都要使用循环，要注意根据问题确定循环变量的初值，终值或结束条件，更要注意用来表示计数，和，阶乘的变量的初值。   例：用随机函数产生100个[0,99] 范围内的随机整数，统计个位上的数字分别为1，2，3，4，5，6，7，8，9，0的数字并打印出来。 本题使用数组来处理， 用数组a[100]存放产生的100个随机整数，数组X[10]来存放个位上的数字分别
推荐系统算法概述
小龙王2010
11-14 1714
文章来源：http://www.cnblogs.com/luchen927/archive/2012/02/04/2334316.html 前一阵子准备毕业论文的开题，一直在看推荐系统相关的论文。对推荐系统有了一个更加清晰和理性的认识，也对推荐算法有了深入了解。借此机会总结分享一下，大家多多拍砖。 推荐系统的出现 　　随着互联网的发展，人们正处于一个信息爆炸的时代。相
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 414
算法014：找到字符串中所有字母异位词
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 379
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值