高斯消元法解n阶线性方程组 Algorithm 数学计算 240万源代码下载-
&文件名称: 高斯消元法解n阶线性方程组
& & & & &&]
&&所属分类:
&&开发工具: Visual C++
&&文件大小: 263 KB
&&上传时间:
&&下载次数: 249
&&提 供 者:
&详细说明：高斯消元法解n阶线性方程组 这里是数学方法中常用的计算程序-Gauss elimination method for n-linear equations here is the mathematical methods used in calculation procedures
文件列表(日期：~)(点击判断是否您需要的文件，如果是垃圾请在下面评价投诉):
&&高斯消元法解n阶线性方程组&&.........................\Debug&&.........................\ReadMe.txt&&.........................\StdAfx.cpp&&.........................\StdAfx.h&&.........................\&&.........................\高斯消元法解n阶线性方程组.dsp&&.........................\高斯消元法解n阶线性方程组.dsw&&.........................\高斯消元法解n阶线性方程组.ncb&&.........................\高斯消元法解n阶线性方程组.opt&&.........................\高斯消元法解n阶线性方程组.plg
&[]:下载了,打开了,研究一下先.谢谢!&[]:不能解压或下载失败&[]:很好，推荐下载
&近期下载过的用户:
&相关搜索:
&&&&&&&&&&
&输入关键字，在本站240万海量源码库中尽情搜索：
&[] - 采用高斯消元法实现的n阶线性方程组求解程序；
&[] - 高斯法解线性方程组
&[] - 利用高斯全选主元消去解线性方程组，用C＋＋语言写
&[] - 牛顿法解方程之混沌情况，帮助你对牛顿法解方程的领悟，具有非常强的视觉冲击力，美仑美奂，不看将后悔一辈子的！
&[] - 人工神经网络bp 算法是用于数学建模Alife.c 基于遗传算法的人工生命模拟源程序, 输入数据文件world GA_nn.c 基于遗传算法优化神经网络结构源程序,输入数据文件sample Patmat.c 基于遗传算法提取基元图形源序
&[] - 线性代数方程组的求解全选主元高斯消去法全选主元高斯约当消去法复系数方程组的全选主元高斯消去法
&[] - 电力系统计算应用广泛的高斯消元法，用来对参数矩阵进行降阶消元。
&[] - 清华大学2002年出版的《科学与工程数值计算算法VC＋＋》配套源码，包括复数计算、矩阵运算、插值计算、线性非线性方程组求解、数值积分、数值拟和与逼近等算法和类，对于科学和工程数值计算很有参考价值！
&[] - 高斯列主元消元法，
这只是我个人的一种解法，仅供参考。
&[] - 高斯消去法是一个古老的求解线性方程组的方法，但它的改进、变形得到的主元素消去法仍然是计算机上常用的计算方法。高斯消元法 -
高斯消元法该方法以数学家高斯命名，由拉布扎比.伊丁特改进，发表于法国但最早出现于中国古籍《九章算术》，成书于约公元前150年。
高斯消元法 -
这个算法的原理是：首先，要将L1 以下的等式中的x 消除，然后再将L2 以下的等式中的y 消除。这样可使整个方程组变成一个三角形似的格式。通常人或电脑在应用高斯消元法的时候，不会直接写出方程组的等式来消去未知数，反而会使用矩阵来计算。之后再将已得出的答案一个个地代入已被简化的等式中的未知数中，就可求出其余的答案了。在刚才的例子中，我们将二分之三 L1和L2相加，就可以将L2 中的X消除了。然后再将L1 和L3相加，就可以将L3 中的x 消除。高斯消元法可用来找出下列方程组的解或其解的限制：2x + y - z = 8 (L1)-3x - y + 2z = -11 (L2)-2x + y + 2z = -3 (L3)我们可以这样写：L2 + 3/2 L1→ L2L3 + L1 → L3结果就是：2x + y - z = 81/2 y + 1/2 z = 12y + z = 5现在将 - 4L2 和L3 相加，就可将L3 中的y 消除：L3 + -4 L2 → L3其结果是：2x + y - z = 81/2y + 1/2z = 1-z = 1这样就完成了整个算法的初步，一个三角形的格式(指:变量的格式而言,上例中的变量各为3,2,1个)出现了。第二步，就是由尾至头地将已知的答案代入其他等式中的未知数。第一个答案就是：z = -1然后就可以将z 代入L2 中，立即就可得出第二个答案：y = 3之后，将z 和y 代入L1 之中，最后一个答案就出来了：x = 2就是这样，这个方程组就被高斯消元法解决了。这种算法可以用来解决所有线性方程组。即使一个方程组不能被化为一个三角形的格式，高斯消元法仍可找出它的解。例如在第一步化简后，L2 及L3 中没有出现任何y ，没有三角形的格式，照着高斯消元法而产生的格式仍是一个行梯阵式。这情况之下，这个方程组会有超过一个解，当中会有至少一个变量作为答案。每当变量被锁定，就会出现一个解。以下就是使用矩阵来计算的例子：2 1 -1 8-3 -1 2 -11-2 1 2 -3跟着以上的方法来运算，这个矩阵可以转变为以下的样子：2 1 -1 80 1/2 1/2 10 0 -1 1这矩阵叫做“行梯列式”。最后，可以利用同样的算法产生以下的矩阵，便可把所得出的解或其限制简明地表示出来：1 0 0 20 1 0 30 0 1 -1最后这矩阵叫做“简化行梯列式”，亦是高斯－约当消元法指定的步骤。
高斯消元法 -
找出逆矩阵高斯消元法可以用来找出一个可逆矩阵的逆矩阵。设A 为一个N * N的矩阵，其逆矩阵可被两个分块矩阵表示出来。将一个N * N单位矩阵 放在A 的右手边，形成一个N * 2N的分块矩阵B = [A,I] 。经过高斯消元法的计算程序后，矩阵B 的左手边会变成一个单位矩阵I ，而逆矩阵A ^(-1) 会出现在B 的右手边。假如高斯消元法不能将A 化为三角形的格式，那就代表A 是一个不可逆的矩阵。应用上，高斯消元法极少被用来求出逆矩阵。高斯消元法通常只为线性方程组求解。计出秩的基本算法高斯消元法可应用在任何m * n的矩阵A。在不可减去某数的情况下，我们都只有跳到下一行。以一个6 * 9的矩阵作例，它可以变化为一个行梯阵式：1 * 0 0 * * 0 * 00 0 1 0 * * 0 * 00 0 0 1 * * 0 * 00 0 0 0 0 0 1 * 00 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0而矩阵中的 *' 是一些数字。这个梯阵式的矩阵T 会有一些关于A的资讯：A 的秩是5，因为T 有5行非0的行；A 的列的向量空间，可从A 的第1、3、4、7和9列中得知，其数值在矩阵T 之中；矩阵中的 *' 表示了A 的列可怎样写为列中的数的组合。
高斯消元法 -
高斯消元法的算法复杂度是O（n3）；这就是说，如果系数矩阵的是n × n，那么高斯消元法所需要的计算量大约与n3成比例。高斯消元法可用在任何域中。高斯消元法对于一些矩阵来说是稳定的。对于普遍的矩阵来说，高斯消元法在应用上通常也是稳定的，不过亦有例外。
高斯消元法 -
高斯消元法的其中一种伪代码:这个算法和之前谈及的有点儿不同，它由绝对值最大的部分开始做起，这样可以改善算法上的稳定性。将经过调换后的第一列作为起点，这算法由左至右地计算。每作出以下两个步骤，才跳到下一列：高斯消元法1.定出每列的最后一个非0的数，将每行的数字除以该数，使到每行的第一个数成为1；2.将每行的数字减去第一行的第一个数的某个倍数。所有步骤完成后，这个矩阵会变成一个行梯阵式，再用代入法就可解决这个方程组。线性方程组其实是相当容易解决的，基本的思想就是消元。但是当未知数较多时，解起来也蛮头疼的。在这里向大家介绍高斯消元法。例如解如下四元一次方程组：高斯消元法高斯消元法除去各未知数，将各数排在一起，成为矩阵：高斯消元法为方便起见，用r2+r1表示把第一行各数加到第二行对应数上。r2-2*r1, r3-3*r1, r4-4*r1, 可得：r3+4*r2, r4+3*r2, 可得：r4-2*r3, 可得：高斯消元法化为方程组形式则为：高斯消元法从而，可得：X4=4X3=3X2=2X1=1.说明：对于矩阵采取的变换的合理性，可对照相应方程组的变换加以理解。
为本词条添加和相关影像
互动百科的词条（含所附图片）系由网友上传，如果涉嫌侵权，请与客服联系，我们将按照法律之相关规定及时进行处理。未经许可，禁止商业网站等复制、抓取本站内容；合理使用者，请注明来源于。
登录后使用互动百科的服务，将会得到个性化的提示和帮助，还有机会和专业认证智愿者沟通。
您也可以使用以下网站账号登录：
此词条还可添加&
编辑次数：9次
参与编辑人数：7位
最近更新时间： 20:04:16
贡献光荣榜
扫描二维码用手机浏览词条
保存二维码可印刷到宣传品
扫描二维码用手机浏览词条
保存二维码可印刷到宣传品BP神经网络_图文_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
BP神经网络
上传于||文档简介
&&人​工​智​能​B​P​神​经​网​络​,​解​说​P​P​T
大小：779.00KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢1222人阅读
网络模型处理信息的基本原理是：输入信号通过中间节点（隐层点）作用于输出节点，经过非线形变换，产生输出信号，网络训练的每个样本包括输入向量和期望输出量，网络输出值与期望输出值之间的偏差，通过调整输入节点与隐层节点的联接强度取值和隐层节点与输出节点之间的联接强度以及阈值，使误差沿梯度方向下降，经过反复学习训练，确定与最小误差相对应的网络参数（权值和阈值），训练即告停止。此时经过训练的神经网络即能对类似样本的输入信息，自行处理输出误差最小的经过非线形转换的信息。
一 BP神经网络模型
网络模型包括其输入输出模型、作用函数模型、误差计算模型和自学习模型。
（）节点输出模型
隐节点输出模型：q
输出节点输出模型：q
f-非线形作用函数；q -神经单元阈值。
（2）作用函数模型
作用函数是反映下层输入对上层节点刺激脉冲强度的函数又称刺激函数，一般取为(0,1)内连续取值Sigmoid函数：&&&&&&&&&&&&&&&&&&&&&&& f(x)=1/(1+e-x)&&&&&&&&&&&&&&&&&& （3）
（3）误差计算模型
误差计算模型是反映神经网络期望输出与计算输出之间误差大小的函数：
&&&&&&&&&&&&&&&&&&& Ep=1/2×∑(tpi-Opi)2&&&&&&&&&&&&&&& (4)
tpi- i节点的期望输出值；Opi-i节点计算输出值。
（4）自学习模型
神经网络的学习过程，即连接下层节点和上层节点之间的权重拒阵Wij的设定和误差修正过程。BP网络有师学习方式-需要设定期望值和无师学习方式-只需输入模式之分。自学习模型为
&&&&&&&&&&&&&&&&&&&&&& △Wij(n+1)= h ×Фi×Oj+a×△Wij(n) （5）
h -学习因子；Фi-输出节点i的计算误差；Oj-输出节点j的计算输出；a-动量因子。
二 BP网络模型的缺陷分析及优化策略
（1）学习因子h 的优化
采用变步长法根据输出误差大小自动调整学习因子，来减少迭代次数和加快收敛速度。
h =h +a×(Ep(n)- Ep(n-1))/ Ep(n) a为调整步长，0~1之间取值（6）
（2）隐层节点数的优化
&&&& 隐 节点数的多少对网络性能的影响较大，当隐节点数太多时，会导致网络学习时间过长，甚至不能收敛；而当隐节点数过小时，网络的容错能力差。利用逐步回归分析法并进行参数的显著性检验来动态删除一些线形相关的隐节点，节点删除标准：当由该节点出发指向下一层节点的所有权值和阈值均落于死区（通常取±0.1、±0.05等区间）之中，则该节点可删除。最佳隐节点数L可参考下面公式计算：
L=(m+n)1/2+c (7)
m-输入节点数；n-输出节点数；c-介于1～10的常数。
（3）输入和输出神经元的确定
利用多元回归分析法对神经网络的输入参数进行处理，删除相关性强的输入参数，来减少输入节点数。
（4）算法优化
由于BP算法采用的是剃度下降法，因而易陷于局部最小并且训练时间较长。用基于生物免疫机制地既能全局搜索又能避免未成熟收敛的免疫遗传算法IGA取代传统BP算法来克服此缺点。
该程序实现神经网络的BP算法，输入节点数，输出节点数，隐层数，隐层节点数任意，由用户决定。其中隐层数指的是总共曾数包含输出层，比如说异或算法为2层，第一层节点数为2，第二层也即输出层节点数为1，输入点数为2 。但是该程序对异或算法实现并不理想，对多层多节点的神经网络有较好的结果。#include &iostream.h&
#include &time.h&
#include &stdlib.h&
#include&fstream&
#include &math.h&
#include &stdio.h &
#define MAXCOUNT 1e5 //迭代训练次数上限
// 精度0.001的随机浮点数,范围在-0.5——0.5
float randf()
return (float)((rand() % 1001) * 0.001f-0.5);
//高斯随机数产生函数
double gaussrand()
{&& static double V1, V2, S;
&&&& static int phase = 0;
&&&& double X;
&&&& if(phase == 0) {
&&&&& double U1 = (double)rand() / RAND_MAX;
&&&&& double U2 = (double)rand() / RAND_MAX;
&&&&& V1 = 2 * U1 - 1;
&&&&& V2 = 2 * U2 - 1;
&&&&& S = V1 * V1 + V2 * V2;
&& } while(S &= 1 || S == 0);
&& X = V1 * sqrt(-2 * log(S) / S);
&&&& } else
&& X = V2 * sqrt(-2 * log(S) / S);
&&&& phase = 1 -
&&&& return X;
//定义一个多层前向BP网络
double ***p;//记录所有的权值
double ***//记录所有的权值增量
int *//记录每一层的节点数
double **//记录每组每一层的节点的输出值
double **//记录每组每一层的节点的ddlj
double **pX;//记录输入样本
double **pY;//记录输入理想输出值
{ Sidenum=0;
Inputnodenum=0;
outputnodenum=0;
yangbenzushu=0;}
for(int m=0;m&Sm++)
&&&&&&&& for(int n=0;n&pnode[m+1];n++)
&& {delete[] p[m][n];
&& delete[] ddp[m][n];}
&& delete[] p[m];
&&&&& delete[] ddp[m];
&&&& delete[]
&&&&& delete[]
&& p=NULL;
&&&&& ddp=NULL;
if(p==NULL)
for(int M=0;M&SM++)
{delete[] pnodey[M];
delete[] ddlj[M];
pnodey=NULL;
ddlj=NULL;
//完成所有权值的初始化
void getW(int sidenum,int inputnodenum,int outputnodenum1,int yangbenzu)
{&& Sidenum=
&&&& yangbenzushu=
&&& Inputnodenum=
outputnodenum=outputnodenum1;
p=new double **[sidenum];
ddp=new double **[sidenum];
pnode=new int [sidenum+1];//包含输入层输出层每一层的节点数
for(int i=0;i&sidenum+1;i++)
int data=0;
cout&&&请输入第&&&i&&&层节点数&&&
&&& pnode[i]=
for (int j=0;j&j++)
{&&& p[j]=new double* [pnode[j+1]];
&&&& ddp[j]=new double*[pnode[j+1]];
&&&&&&& for (int k=0;k&pnode[j+1];k++)
&&&&&&& {&& ddp[j][k]=new double[pnode[j]+1];
&&&&&&&&&&& p[j][k]=new double[pnode[j]+1];
&&&&&&&&&&& for (int t=0;t&pnode[j]+1;t++)
&&&&&&&&&&& { ddp[j][k][t]=0;//每一层的权值初始化为0
&&&&&&&&&&&&&&
&&&&& if(t==0)p[j][k][t]=-fabs(randf());//每一层的阀值初始化
&&&&&&&&&&&&&&& else p[j][k][t]=randf();//每一层的权值初始化
//为记录每一层的节点的输出值和ddlj的指针开辟内存
pnodey=new double *[Sidenum];
ddlj=new double *[Sidenum];
for(int p=0;p&Sp++)
pnodey[p] = new double [pnode[p+1]+1];
&&&&&& ddlj[p]=new double [pnode[p+1]];
&&&&&&&&&&&&
&&&&&&& pnodey[p][0]=1;//每组每层的首值为1
/**********************/
//每个节点输出函数
double fas(double s)
t=1.0/(exp(-s)+1);
/************************************************/
//该函数用来记录样本值和理想输出值
void INPUT(int yangbenzushu1 )
{&& pY=new double*[yangbenzushu1];
pX=new double*[yangbenzushu1];
for(int yu=0;yu&yangbenzushu1;yu++)
{ pX[yu]=new double[Inputnodenum+1];
&&& pY[yu]=new double[outputnodenum+1];
//每组样本的首值赋为1
&& for(int yu1=0;yu1&yangbenzushu1;yu1++)
&& { pX[yu1][0]=1;
&&&& pY[yu1][0]=1;
&& cout&&&请输出样本输入值&&&
for(int yuy=0;yuy&yangbenzushu1;yuy++)
for(int yy=1;yy&=Iyy++)
{ if(yy==Inputnodenum) cout&&
&& cout&&&X[&&&yuy&&&]&&&&[&&&yy&&&]=&&&' ';
&& cin&&pX[yuy][yy];
cout&&&请输出样本理想输出值&&&
for(int yuy1=0;yuy1&yangbenzushu1;yuy1++)
for(int yy1=1;yy1&=yy1++)
{ //if(yy==Inputnodenum) cout&&
&& cout&&&Y[&&&yuy1&&&]&&&&[&&&yy1&&&]=&&&' ';
&& cin&&pY[yuy1][yy1];
/****************************************************************************/
//计算每个节点的输出值函数
double computeYl(int KK)//KK代表第几组组号
{ double sum1=0;
//把所有的层的每一个节点的输出值算出来并记录在 pnodey里,不包含输入点值
&& for(int y=0;y&Sy++)//层数
&&& for(int r=1;r&pnode[y+1]+1;r++)//节点数
&&& { double sum=0;
&&&& for(int z=0;z&pnode[y]+1;z++)//前一层的节点数
&&&& {if(y==0)sum+= pX[KK][z]*p[y][r-1][z];
&&&&&&&& else
&&&&&&&&&&&&&&&& sum+=pnodey[y-1][z]*p[y][r-1][z];
&&&&&&&&&& pnodey[y][r]=fas(sum);
&& for(int j=1;j&=j++)
sum1+=pow(pY[KK][j]-pnodey[Sidenum-1][j],2);
return sum1;
/**********************************************************/
//Compute Back-Propagation-Errors
void ComputeBackPropagationErrors(int gf)//gf代表组号
{//计算所有的ddlj[][]
//for(int gf=0;gf&gf++)//组数
for(int q=Sidenum-1;q&=0;q--)//从最后一层开始
&& if (q==Sidenum-1)//如果是最外一层的话
&& {&& for(int rt=0;rt&pnode[q+1];rt++)//每层的节点数
&&&&&&&&&&&&&& ddlj[q][rt]=pnodey[q][rt+1]*(1-pnodey[q][rt+1])*(pY[gf][rt+1]-pnodey[q][rt+1]) ;
&&&&&& else
&&&& for(int ry=0;ry&pnode[q+1];ry++)
&&&& {&& double sumtemp=0;
&&&&& for(int fg=0;fg&pnode[q+2];fg++)
&&&&&& sumtemp+=ddlj[q+1][fg]*p[q+1][fg][ry+1];
&&&&&&&&&&&&&&&&&&& ddlj[q][ry] = pnodey[q][ry+1]*(1-pnodey[q][ry+1])*
//计算所有的ddp[][]
//for(int gf1=0;gf1&gf1++)//组数
&& for(int l=0;l&Sl++)//层数
&&& for(int JJ=0;JJ&pnode[l+1];JJ++)//每一层的节点数
&&&& for(int i=0;i&pnode[l]+1;i++)//前一层的节点数
&&&& { if(l==0)//如果是第一层的话，y值为输入的X值
&&&&&&& ddp[l][JJ][i]=ddlj[l][JJ]*pX[gf][i];
&&&&&& else
&&&&& ddp[l][JJ][i]=ddlj[l][JJ]*pnodey[l-1][i];
/*************************************************************************/
void UpdatetheWeightsusingBPAlgorithm()
{ for(int cent=0;cent&Scent++)//层数
&&& for(int J=0;J&pnode[cent+1];J++)//每一层的节点数
&&&&&& for(int i=0;i&pnode[cent]+1;i++)//前一层的节点数
&&&& p[cent][J][i]+=0.2*ddp[cent][J][i];
/***************************************************************************/
double xunlianErrors()//定义训练误差函数
{ double error=0;
&& double sum=0;
&& double temp=0;
&& double temp1=0;
for(int gf1=0;gf1&gf1++)//组数
{temp= computeYl(gf1);
&& //temp1=zhengquelv(gf1);
&& //sum+=temp1;
for(int jj=1;jj&=jj++)
&&&& cout&&pnodey[Sidenum-1][jj];
&&&&&& error+=
// sum=sum/
&&&& cout&&&用训练集所得到的正确率：&&&sum&&
return error/
/****************************************************************************/
double jiaoyanErrors(int yangbenzushu1 )//定义校验误差函数
{double error=0;
&& double sum=0;
&& double temp=0;
&& double temp1=0;
for(int gf1=0;gf1&yangbenzushu1;gf1++)//组数
{temp= computeYl(gf1);
&& for(int jj=1;jj&=jj++)
&&&& cout&&pnodey[Sidenum-1][jj];
&& //temp1=zhengquelv(gf1);
&& //sum+=temp1;
&&&&&& error+=
//sum=sum/yangbenzushu1;
&& // cout&&&用校验集所得到的正确率：&&&sum&&
return error/yangbenzushu1;
/********************************************************************/
double zhengquelv(int KK)
{int count=0;
&&&& double av=0;
//for(int gf1=0;gf1&gf1++)//组数
for(int jj=1;jj&=jj++)
{if (pnodey[Sidenum-1][jj]&0) pnodey[Sidenum-1][jj]=1;
&&& else pnodey[Sidenum-1][jj]=0;
&& if(pY[KK][jj]==pnodey[Sidenum-1][jj])count++;
&&& av=(double)count/
/***********************************************************************/
void freeINput()
if(pX!=NULL)
{for(int u=0;u&u++)
&&&&&&& delete []pX[u];
&&&& delete []pX;
&&&&& pX=NULL;
if(pY!=NULL)
{for(int u1=0;u1&u1++)
&&&&&&& delete []pY[u1];
&&&&&&&& delete []pY;
&&& pY=NULL;
/***************************************************************/
//输出所有的权值
void wputout()
{&& for (int j=0;j&Sj++)
&& {&& cout&&&第[&&&j+1&&&]层权值为：&&&
&&&&&&&&&&& for (int k=0;k&pnode[j+1];k++)
&&& { //if(k==pnode[j+1]-1) cout&&
&&&&&&&&&&&&&& for (int t=0;t&pnode[j]+1;t++)
&&&&&&&&&&&&&&&& cout&&p[j][k][t]&&' ';
&&&&&&& if(t==pnode[j]) cout&&
/**********************************************************/
void main()
int count=0;//用来统计所用的迭代次数
int inputnodenum,outnodenum,sidenum,
cout&&&请输入输入点数，输出点数，隐层数&&&
cin&&inputnodenum&&outnodenum&&
cout&&&请输入样本组数&&&
//第一步初始化所有的权值
bp.getW(sidenum,inputnodenum,outnodenum,yangbenzunum);
//第二步输入样本组
bp.INPUT(yangbenzunum);
for(;;count++)
double sum=0;
&&& double temp=0;
for(int fuzu=0;fuzu&fuzu++)
&& //第三步计算所有y值
puteYl(fuzu);
//第四步Compute Back-Propagation-Errors
<puteBackPropagationErrors(fuzu);
//第五步Update the Weights using BP Algorithm
bp.UpdatetheWeightsusingBPAlgorithm();
&&& sum&#43;=
//第六步判断是否收敛
error=sum/2*
//freopen(&debug\\out.txt&,&w&,stdout);
//fp=freopen( &out.txt&, &w&, stdout) ;
// cout&&count&&' '&&error&&
// fclose(stdout);//关闭文件
/*if(count==1000)cout&&error&&
&&& if(count==1500)cout&&error&&
if(count==1600)cout&&error&&*/
//if(count==10000)cout&&error&&
if(error&1.02)
&&&&&&&&& cout&&&循环收敛&&&&迭代次数为：&&&count&&
&& //bp.freeINput();//释放X Y空间
cout&&&权&#20540;为：&&&
bp.wputout();
double XUNLIANER=bp.xunlianErrors();
//cout&&&训练误差为：&&&XUNLIANER&&
bp.freeINput();//释放X Y空间
cout&&&请输入校验样本: &&&
int jiaoyannum=0;
bp.INPUT(jiaoyannum);
double jiaoyanER=bp.jiaoyanErrors(jiaoyannum);
cout&&&校验误差为:&&&jiaoyanER&&
//fclose( stdout ) ;*/
简介：BP（Back Propagation）网络是1986年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权&#20540;和阈&#20540;，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hide layer)和输出层(output
　　摘 要：ＢＰ神经网络算法是在ＢＰ神经网络现有算法的基础上提出的，是通过任意选定一组权&#20540;，将给定的目标输出直接作为线性方程的代数和来建立线性方程组，解得待求权，不存在传统方法的局部极小及收敛速度慢的问题，且更易理解。
　　关键词：固定权&#20540;；ｇａｕｓｓ消元法；ＢＰ算法
　　人工神经网络（ａｒｔｉｆｉｃｉａｌ ｎｅｕｒａｌ ｎｅｔｗｏｒｋｓ，ＡＮＮ）系统是２０世纪４０年代后出现的，它是由众多的神经元可调的连接权&#20540;连接而成，具有大规模并行处理、分布式信息存储、良好的自组织自学习能力等特点，在信息处理、模式识别、智能控制及系统建模等领域得到越来越广泛的应用。尤其误差反向传播算法（ＥｒｒｏｒＢａｃｋ－ｐｒｏｐａｇａｔｉｏｎ Ｔｒａｉｎｉｎｇ，简称ＢＰ网络）可以&#36924;近任意连续函数，具有很强的非线性映射能力，而且网络的中间层数、各层的处理单元数及网络的学习系数等参数可根据具体情况设定，灵活性很大，所以它在许多应用领域中起到重要作用。近年来，为了解决ＢＰ神经网络收敛速度慢、不能保证收敛到全局最小点，网络的中间层及它的单元数选取无理论指导及网络学习和记忆的不稳定性等缺陷，提出了许多改进算法。
　　１ 传统的ＢＰ算法简述
　　ＢＰ算法是一种有监督式的学习算法，其主要思想是：输入学习样本，使用反向传播算法对网络的权&#20540;和偏差进行反复的调整训练，使输出的向量与期望向量尽可能地接近，当网络输出层的误差平方和小于指定的误差时训练完成，保存网络的权&#20540;和偏差。具体步骤如下：
　　（１）初始化，随机给定各连接权［ｗ］,［ｖ］及阀&#20540;θi，ｒt。
　　（２）由给定的输入输出模式对计算隐层、输出层各单元输出
　　ｂj＝ｆ（■wijai-θj） ｃt＝ｆ（■vjtbj－ｒt）
　　式中：ｂj为隐层第ｊ个神经元实际输出；ｃt为输出层第ｔ个神经元的实际输出；wij为输入层至隐层的连接权；vjt为隐层至输出层的连接权。
　　ｄtk＝（ｙtk－ｃt）ｃt（１－ｃt） ｅjk＝［■dtvjt］ ｂj（１－ｂj）
　　式中：ｄtk为输出层的校正误差；ｅjk为隐层的校正误差。
　　（３）计算新的连接权及阀&#20540;，计算公式如下：
　　ｖjt（ｎ＋１）＝ｖjt（ｎ）＋?琢ｄtkｂj ｗij（ｎ＋１）＝ｗij（ｎ）＋?茁ｅjkａik
　　ｒt（ｎ＋１）＝ｒt（ｎ）＋?琢ｄtk θj（ｎ＋１）=θj（ｎ）＋?茁ｅjk
　　式中：?琢，?茁为学习系数（０＜?琢＜１，０＜?茁＜１）。
　　（４）选取下一个输入模式对返回第２步反复训练直到网络设输出误差达到要求结束训练。
　　传统的ＢＰ算法，实质上是把一组样本输入/输出问题转化为一个非线性优化问题，并通过负梯度下降算法，利用迭代运算求解权&#20540;问题的一种学习方法，但其收敛速度慢且容易陷入局部极小，为此提出了一种新的算法，即高斯消元法。
　　２ 改进的ＢＰ网络算法
　　２．１ 改进算法概述
　　此前有人提出：任意选定一组自由权，通过对传递函数建立线性方程组，解得待求权。本文在此基础上将给定的目标输出直接作为线性方程等式代数和来建立线性方程组，不再通过对传递函数求逆来计算神经元的净输出，简化了运算步骤。没有采用误差反馈原理，因此用此法训练出来的神经网络结果与传统算法是等效的。其基本思想是：由所给的输入、输出模式对通过作用于神经网络来建立线性方程组，运用高斯消元法解线性方程组来求得未知权&#20540;，而未采用传统ＢＰ网络的非线性函数误差反馈寻优的思想。
　　２．２ 改进算法的具体步骤
　　对给定的样本模式对，随机选定一组自由权，作为输出层和隐含层之间固定权&#20540;，通过传递函数计算隐层的实际输出，再将输出层与隐层间的权&#20540;作为待求量，直接将目标输出作为等式的右边建立方程组来求解。
　　现定义如下符号（见图１）：ｘ （p）输入层的输入矢量；ｙ （p）输入层输入为ｘ（p）时输出层的实际输出矢量；ｔ （p）目标输出矢量；ｎ，ｍ，ｒ分别为输入层、隐层和输出层神经元个数；Ｗ为隐层与输入层间的权矩阵；Ｖ为输出层与隐层间的权矩阵。具体步骤如下：
　　（１）随机给定隐层和输入层间神经元的初始权&#20540;ｗij。
　　（２）由给定的样本输入ｘi（p）计算出隐层的实际输出ａj（p）。为方便起见将图１网络中的阀&#20540;写入连接权中去，令：隐层阀&#20540;θj＝ｗnj，ｘ（ｎ）＝－１，则：
　　ａj（p）=ｆ（■wijｘi（p）） （ｊ＝１，２…ｍ－１）。
　　（３）计算输出层与隐层间的权&#20540;ｖjr。以输出层的第ｒ个神经元为对象，由给定的输出目标&#20540;ｔr（p）作为等式的多项式&#20540;建立方程，用线性方程组表示为：
　　a0（1）v1r&#43;a1（1）v2r&#43;…&#43;am（1）vmr=tr（1）a0（2）v1r&#43;a1（2）v2r&#43;…&#43;am（2）vmr=tr（2） ……a0（p）v1r&#43;a1（p）v2r&#43;…&#43;am（p）vmr=tr（p） 简写为：Ａｖ＝Ｔ
　　为了使该方程组有唯一解，方程矩阵Ａ为非奇异矩阵，其秩等于其增广矩阵的秩，即：ｒ（Ａ）＝ｒ（Ａ┊Ｂ），且方程的个数等于未知数的个数，故取ｍ＝ｐ，此时方程组的唯一解为：Ｖｒ＝［ｖ0r，ｖ2r，…ｖmr］（ｒ＝０，１，２…ｍ－１）
　　（４）重复第三步就可以求出输出层ｍ个神经元的权&#20540;，以求的输出层的权矩阵加上随机固定的隐层与输入层的权&#20540;就等于神经网络最后训练的权矩阵。
　　３ 计算机运算实例
　　现以神经网络最简单的ＸＯＲ问题用ＶＣ编程运算进行比较（取神经网络结构为２－４－１型），传统算法和改进ＢＰ算法的误差（取动量因子α＝０．００１ ５，步长η＝１．６５３）
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：61969次
排名：千里之外
原创：14篇
转载：15篇
(4)(1)(4)(1)(13)(6)}