神经网络的偏差和方差,神经网络均方误差公式

1、你好，想跟你要一下神经网络的代码，看到你之前解答过问题，谢谢了

// BP.cpp : Defines the entry point for the console application.
//该程序实现神经网络的BP算法，输入节点数，输出节点数，隐层数，隐层节点数任意，由用户决定。
//其中隐层数指的是总共层数包含输出层，比如说异或算法为2层，第一层节点数为2，第二层也即输出层节点数为1，输入点数为2 。
//但是该程序对异或算法实现并不理想，对多层多节点的神经网络有较好的结果
#include "stdafx.h"
#include "iostream.h"
#include
#include
#include
#include
#include "stdio.h "
#define MAXCOUNT 1e5 //迭代训练次数上限 1的10的正5次幂
//精度0.001的随机浮点数,范围在-0.5——0.5
//rand()取0到32767,最大为2147483647. %模运算表示余数为0到1000之间，所以乘上浮点数0。001f就是0-1之间的数，再减去0.5,就是-0.5到+0.5
float randf()
{
return (float)((rand() % 1001) * 0.001f-0.5);
}
//高斯随机数产生函数
//这样生成的高斯分布随机数序列的期望为0.0，方差为1.0。若指定期望为E，方差为V，则只需增加：X = X * V + E;
double gaussrand()
{
static double V1, V2, S;
static int phase = 0;
double X;
if(phase == 0) {
do {
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 - phase;
return X;
}
//定义一个多层前向BP网络
class BP
{
public:
double ***p;//记录所有的权值
double ***ddp;//记录所有的权值增量
int *pnode;//记录每一层的节点数
double **pnodey;//记录每组每一层的节点的输出值
double **ddlj;//记录每组每一层的节点的ddlj
double **pX; //记录输入样本
double **pY; //记录输入理想输出值
int Sidenum; //隐层数目
int Inputnodenum;
int outputnodenum;
int yangbenzushu;
BP()
{
Sidenum=0;
Inputnodenum=0;
outputnodenum=0;
yangbenzushu=0;
}
~BP()
{
for(int m=0;m {
for(int n=0;n

{
delete[] p[m][n];
delete[] ddp[m][n];
}
delete[] p[m];
delete[] ddp[m];
}
delete[] p;
delete[] ddp;
p=NULL;
ddp=NULL;
if(p==NULL)
delete [] pnode;
for(int M=0;M {
delete[] pnodey[M];
delete[] ddlj[M];
}
delete[] pnodey;
delete[] ddlj;
pnodey=NULL;
ddlj=NULL;
}
//完成所有权值的初始化
void getW(int sidenum,int inputnodenum,int outputnodenum1,int yangbenzu)
{
Sidenum=sidenum;
yangbenzushu= yangbenzu;//样本组数目
Inputnodenum=inputnodenum;
outputnodenum=outputnodenum1;
p=new double **[sidenum];//记录所有权值
ddp=new double **[sidenum];//权值增量
pnode=new int [sidenum+1];//包含输入层，输出层每一层的节点数.
for(int i=0;i {
int data=0;
cout<<"请输入第"< cin>>data;
pnode[i]=data;
}
for (int j=0;j {
p[j]=new double* [pnode[j+1]]; //首先P[j]层有多少个节点,就有多少个指针,每个指针指向一个权值数组.因为p[j]是二级指针,存放的是某指针的地址,某指针可以指向一维数组.
ddp[j]=new double*[pnode[j+1]];//同上
for (int k=0;k

{
ddp[j][k]=new double[pnode[j]+1];//表示第j层的第k个节点指向的是一个数组,这个数组里存的是这个节点的权值.
p[j][k]=new double[pnode[j]+1];
for (int t=0;t

{
ddp[j][k][t]=0;//每一层的权值初始化为0 表示的是第j层的第k个节点,第t个输入的输入权值.
if(t==0)p[j][k][t]=-fabs(randf());//每一层的阀值初始化 第0个元素.
else p[j][k][t]=randf();//每一层的权值初始化
}
}
}
//为记录每一层的节点的输出值和ddlj的指针开辟内存
pnodey=new double *[Sidenum]; //一共有Sidenum层.
ddlj=new double *[Sidenum];
for(int p=0;p {
pnodey[p] = new double [pnode[p+1]+1];//每层一共有节点数+1个输出
ddlj[p]=new double [pnode[p+1]];// 这个是做什么的？？
pnodey[p][0]=1;//每组每层的首值为1,这个值是为了与阈值相乘,这也是为什么会有上面+1个输出
}
}
/**********************/
//每个节点输出函数
double fas(double s)
{
double t;
t=1.0/(exp(-s)+1);
return t;
}
/************************************************/
//该函数用来记录样本值和理想输出值
void INPUT(int yangbenzushu1 )
{
pY=new double*[yangbenzushu1];//yangbenzushu1数量个理想输出
pX=new double*[yangbenzushu1];//yangbenzushu1数量个样本
for(int yu=0;yu {
pX[yu]=new double[Inputnodenum+1];//每个样本的维数是输入点个数+1
pY[yu]=new double[outputnodenum+1];//输出的维数也是输出点个数+1
}
//每组样本的首值赋为1， 这样就可以使下标对应的比较好
for(int yu1=0;yu1 {
pX[yu1][0]=1;
pY[yu1][0]=1;
}
cout<<"请输入样本输入值"< for(int yuy=0;yuy for(int yy=1;yy<=Inputnodenum;yy++)
{
if(yy==Inputnodenum) cout< cout<<"X["< cin>>pX[yuy][yy];
}
cout<<"请输入样本理想输出值"< for(int yuy1=0;yuy1 for(int yy1=1;yy1<=outputnodenum;yy1++)
{ //if(yy==Inputnodenum) cout< cout<<"Y["< cin>>pY[yuy1][yy1];
}
}
/****************************************************************************/
//计算每个节点的输出值
double computeYl(int KK)//KK代表第几组组号
{
double sum1=0;
//把所有的层的每一个节点的输出值算出来并记录在pnodey里,不包含输入点值
for(int y=0;y {
for(int r=1;r

{
double sum=0;
for(int z=0;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<=outputnodenum;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 for(int q=Sidenum-1;q>=0;q--)//从最后一层开始
{
if(q==Sidenum-1)//如果是最外一层的话
{
for(int rt=0;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

{
double sumtemp=0;
for(int fg=0;fg

sumtemp+=ddlj[q+1][fg]*p[q+1][fg][ry+1];
ddlj[q][ry] = pnodey[q][ry+1]*(1-pnodey[q][ry+1])* sumtemp;
}

}

}
//计算所有的ddp[][]
//for(int gf1=0;gf1 for(int l=0;l for(int JJ=0;JJ

for(int i=0;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 for(int J=0;J

for(int i=0;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 {
temp= computeYl(gf1);
//temp1=zhengquelv(gf1);
//sum+=temp1;
for(int jj=1;jj<=outputnodenum;jj++)
cout<

error+=temp;
}
// sum=sum/yangbenzushu;
cout<<"用训练集所得到的正确率："< return error/yangbenzushu;
}
/****************************************************************************/
double jiaoyanErrors(int yangbenzushu1 )//定义校验误差函数
{
double error=0;
double sum=0;
double temp=0;
double temp1=0;
for(int gf1=0;gf1 {
temp= computeYl(gf1);
for(int jj=1;jj<=outputnodenum;jj++)
cout<

//temp1=zhengquelv(gf1);
//sum+=temp1;
error+=temp;
}
//sum=sum/yangbenzushu1;
//cout<<"用校验集所得到的正确率："< return error/yangbenzushu1;
}
/********************************************************************/
double zhengquelv(int KK)
{
int count=0;
double av=0;
//for(int gf1=0;gf1 for(int jj=1;jj<=outputnodenum;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/outputnodenum;
return av;
}
/***********************************************************************/
void freeINput()
{
if(pX!=NULL)
{
for(int u=0;u delete []pX[u];
delete []pX;
pX=NULL;
}
if(pY!=NULL)
{
for(int u1=0;u1 delete []pY[u1];
delete []pY;
pY=NULL;
}
}
/***************************************************************/
//输出所有的权值
void wputout()
{
for (int j=0;j {
cout<<"第["< for (int k=0;k

{
//if(k==pnode[j+1]-1) cout< for (int t=0;t

{
cout<

if(t==pnode[j]) cout< }
}
}
}
/**********************************************************/
};
void main()
{
BP bp;
int count=0;//用来统计所用的迭代次数
//FILE *fp;
int inputnodenum,outnodenum,sidenum,yangbenzunum;
double error;
cout<<"请输入：输入点数，输出点数，隐层数"< cin>>inputnodenum>>outnodenum>>sidenum;
cout<<"请输入样本组数"< cin>>yangbenzunum;
//第一步初始化所有的权值
bp.getW(sidenum,inputnodenum,outnodenum,yangbenzunum);
//第二步输入样本组
bp.INPUT(yangbenzunum);
for(;;count++)
{
double sum=0;
double temp=0;
for(int fuzu=0;fuzu {
//第三步计算所有y值
temp=bp.computeYl(fuzu);
//第四步Compute Back-Propagation-Errors
bp.ComputeBackPropagationErrors(fuzu);
//第五步Update the Weights using BP Algorithm
bp.UpdatetheWeightsusingBPAlgorithm();
sum+=temp;
}
//第六步判断是否收敛
error=sum/2*yangbenzunum;
//freopen("debug\\out.txt","w",stdout);
//fp=freopen( "out.txt", "w", stdout) ;
// cout< // fclose(stdout);//关闭文件
/*if(count==1000)cout< if(count==1500)cout< if(count==1600)cout< //if(count==10000)cout< if(error<1.02)
{
cout<<"循环收敛"<<"迭代次数为："< //bp.freeINput();//释放X Y空间
break;
}
}
cout<<"权值为："< bp.wputout();
double XUNLIANER=bp.xunlianErrors();
//cout<<"训练误差为："< bp.freeINput();//释放X Y空间
/*
cout<<"请输入校验样本: "< int jiaoyannum=0;
cin>>jiaoyannum;
bp.INPUT(jiaoyannum);
double jiaoyanER=bp.jiaoyanErrors(jiaoyannum);
cout<<"校验误差为:"< //fclose( stdout ) ;*/
}

谷歌人工智能写作项目：小发猫

2、自己用matlab实现的BP神经网络算法，无法得到预期的效果，主要是误差太大 5

lr=0.05; %lr为学习速率；
err_goal=0.1; %err_goal为期望误差最小值
max_epoch=15000; %max_epoch为训练的最大次数；
a=0.9; %a为惯性系数
Oi=0;
Ok=0; %置隐含层和输出层各神经元输出初值为0
这些初始参数是谁提供给你?
调整一下这些参数看看.

3、求一个4，8，1的bp神经网络模型的matlab代码？

代码如下：直接运行就是了。

P=P=[-1,  -2,    3,    1;       -1,    1,    5,  -3; -2,  3, 4, 6;  1, 2, 3,  4 ];%初始训练值
%  创建一个新的前向神经网络 
net=newff(minmax(P),[8,1],{&＃39;tansig&＃39;,&＃39;purelin&＃39;},&＃39;traingdm&＃39;)
%  当前输入层权值和阈值 
inputWeights=net.IW{1,1} 
inputbias=net.b{1} 
%  当前网络层权值和阈值 
layerWeights=net.LW{2,1} 
layerbias=net.b{2} 
%  设置训练参数 
net.trainParam.show = 50; 
net.trainParam.lr = 0.05; 
net.trainParam.mc = 0.9; 
net.trainParam.epochs = 1000; 
net.trainParam.goal = 1e-3; 
%  调用 TRAINGDM 算法训练 BP 网络 
[net,tr]=train(net,P,T); 
%  对 BP 网络进行仿真 
A = sim(net,P) %最后结果
%  计算仿真误差 
E = T - A 
MSE=mse(E)

4、BP神经网络在线学习的误差计算方法

标准BP算法中，每输入一个样本，都要回传误差并调整权值，这种对每个样本轮训的方法称为“单样本训练”。由于单样本训练遵循的是只顾眼前的“本位主义”原则，只针对每个样本产生的误差进行调整，难免顾此失彼，使训练次数增加，导致收敛速度过慢。因此，有另外一种方法，就是在所有样本输入之后，计算网络的总误差，再根据总误差调整权值，这种累积误差的批处理方式称为“批训练”或“周期训练”。在样本数较多时，批训练比单样本训练的收敛速度更快。

5、BP神经网络预测代码 15

你这是在做时间序列呢。
你可以去《神经网络之家》nnetinfo----》学习教程二--->神经网络在时间序列上的应用
上面有讲解。我把代码摘抄给你
% time series:神经网络在时间序列上的应用
% 本代码出自《神经网络之家》
timeList = 0 :0.01 : 2*pi; %生成时间点
X = sin(timeList); %生成时间序列信号
%利用x(t-5),x(t-4),x(t-3),x(t-2),x(t-1)作为输入预测x(t)，将x(t)作为输出数据
inputData = [X(1:end-5);X(2:end-4);X(3:end-3);X(4:end-2);X(5:end-1)];
outputData = X(6:end);
%使用用输入输出数据（inputData、outputData）建立网络，
%隐节点个数设为3.其中隐层、输出层的传递函数分别为tansig和purelin，使用trainlm方法训练。
net = newff(inputData,outputData,3,{&＃39;tansig&＃39;,&＃39;purelin&＃39;},&＃39;trainlm&＃39;);
%设置一些常用参数
net.trainparam.goal = 0.0001; %训练目标：均方误差低于0.0001
net.trainparam.show = 400; %每训练400次展示一次结果
net.trainparam.epochs = 1500; %最大训练次数：15000.
[net,tr] = train(net,inputData,outputData);%调用matlab神经网络工具箱自带的train函数训练网络
simout = sim(net,inputData); %调用matlab神经网络工具箱自带的sim函数得到网络的预测值
figure; %新建画图窗口窗口
t=1:length(simout);
plot(t,outputData,t,simout,&＃39;r&＃39;)%画图，对比原来的输出和网络预测的输出
%------------------附加:抽取数学表达式----------------------------top
%希望脱离matlab的sim函数来使用训练好网络的话，可以抽取出数学的表达式，|
%这样在任何软件中，只需要按表达式计算即可。 |
%============抽取数学表达式==================
%抽取出网络的权值和阈值
w12 = net.iw{1,1}; %第1层（输入层）到第2层（隐层）的权值
b2 = net.b{1}; %第2层（隐层）的阈值
w23 = net.lw{2,1}; %第2层（隐层）到第3层（输出层）的权值
b3 = net.b{2}; %第3层（输出层）的阈值
%由于有归一化，必须先将归一化信息抓取出来
iMax = max(inputData,[],2);
iMin = min(inputData,[],2);
oMax = max(outputData,[],2);
oMin = min(outputData,[],2);
%方法1：归一化--->计算输出--->反归一化
normInputData=2*(inputData -repmat(iMin,1,size(inputData,2)))./repmat(iMax-iMin,1,size(inputData,2)) -1;
tmp = w23*tansig( w12 *normInputData + repmat(b2,1,size(normInputData,2))) + repmat(b3,1,size(normInputData,2));
myY = (tmp+1).*repmat(oMax-oMin,1,size(outputData,2))./2 + repmat(oMin,1,size(outputData,2));
%方法2：用真正的权值和阈值进行计算
%公式请参考《提取对应原始数据的权重和阈值》
W12 = w12 * 2 ./repmat(iMax&＃39; -iMin&＃39;,size(w12,1),1);
B2 = -w12* (2*iMin ./(iMax - iMin) + 1) + b2;
W23 = w23 .*repmat((oMax -oMin),1,size(w23,2))/2;
B3 = (oMax -oMin) .*b3 /2 + (oMax -oMin)/2 + oMin;
%最终的数学表达式：
myY2 = W23 *tansig( W12 *inputData + repmat(B2,1,size(inputData,2))) + repmat(B3,1,size(inputData,2));

6、怎么用MATLAB计算均方误差啊

mse是检验神经网络算法的误差分析。

1、首先按照下方图片中的代码进行编辑均方误差函数mse代码。

2、编辑完上面图片中的代码之后，继续根据下方图片中的代码进行编辑。

3、编辑完成之后，运行改代码就可以得到想要的均方误差了。

MATLAB是MATrix LABoratory(矩阵实验室)的缩写，是由美国MathWorks公司于20世纪80年代初推出的一套以矩阵计算为基础的、适合多学科、多种工作平台的功能强劲的大型软件。

MATLAB将科学计算、数据可视化、系统仿真和交互式程序设计功能集成在非常便于使用的环境中，具有编程效率高、用户使用方便、扩充能力强、移植性好等特点。经过MathWorks公司的不断完善，目前MATLAB已经发展成为国际上最优秀的高性能科学与工程计算软件之一。

MATLAB和MATHEMATICA、MAPLE并称为三大数学软件。它在数学类科技应用软件中在数值计算方面首屈一指。MATLAB将数值分析、矩阵计算、科学数据可视化以及非线性动态系统的建模和仿真等诸多强大功能集成在一个易于使用的视窗环境中。

为科学研究、工程设计以及必须进行有效数值计算的众多科学领域提供了一种全面的解决方案，并在很大程度上摆脱了传统非交互式程序设计语言(如C、Fortran)的编辑模式，代表了当今国际科学计算软件的先进水平。

7、matlab中用RBF神经网络做预测的代码怎么写

clc;

clearall;

closeall;

%%----BuildatrainingsetofasimilarversionofXOR

c_1=[00];

c_2=[11];

c_3=[01];

c_4=[10];

n_L1=20;%numberoflabel1

n_L2=20;%numberoflabel2

A=zeros(n_L1*2,3);

A(:,3)=1;

B=zeros(n_L2*2,3);

B(:,3)=0;

%createrandompoints

fori=1:n_L1

A(i,1:2)=c_1+rand(1,2)/2;

A(i+n_L1,1:2)=c_2+rand(1,2)/2;

end

fori=1:n_L2

B(i,1:2)=c_3+rand(1,2)/2;

B(i+n_L2,1:2)=c_4+rand(1,2)/2;

end

%showpoints

scatter(A(:,1),A(:,2),[],&＃39;r&＃39;);

holdon

scatter(B(:,1),B(:,2),[],&＃39;g&＃39;);

X=[A;B];

data=X(:,1:2);

label=X(:,3);

%%Usingkmeanstofindcintervector

n_center_vec=10;

rng(1);

[idx,C]=kmeans(data,n_center_vec);

holdon

scatter(C(:,1),C(:,2),&＃39;b&＃39;,&＃39;LineWidth&＃39;,2);

%%Calulatesigma

n_data=size(X,1);

%calculateK

K=zeros(n_center_vec,1);

fori=1:n_center_vec

K(i)=numel(find(idx==i));

end

%UsingknnsearchtofindKnearestneighborpointsforeachcentervector

%thencalucatesigma

sigma=zeros(n_center_vec,1);

fori=1:n_center_vec

[n,d]=knnsearch(data,C(i,:),&＃39;k&＃39;,K(i));

L2=(bsxfun(@minus,data(n,:),C(i,:)).^2);

L2=sum(L2(:));

sigma(i)=sqrt(1/K(i)*L2);

end

%%Calutateweights

%kernelmatrix

k_mat=zeros(n_data,n_center_vec);

fori=1:n_center_vec

r=bsxfun(@minus,data,C(i,:)).^2;

r=sum(r,2);

k_mat(:,i)=exp((-r.^2)/(2*sigma(i)^2));

end

W=pinv(k_mat&＃39;*k_mat)*k_mat&＃39;*label;

y=k_mat*W;

%y(y>=0.5)=1;

%y(y<0.5)=0;

%%trainingfunctionandpredictfunction

[W1,sigma1,C1]=RBF_training(data,label,10);

y1=RBF_predict(data,W,sigma,C1);

[W2,sigma2,C2]=lazyRBF_training(data,label,2);

y2=RBF_predict(data,W2,sigma2,C2);

扩展资料

matlab的特点

1、具有完备的图形处理功能，实现计算结果和编程的可视化；

2、友好的用户界面及接近数学表达式的自然化语言，使学者易于学习和掌握；

3、功能丰富的应用工具箱(如信号处理工具箱、通信工具箱等) ，为用户提供了大量方便实用的处理工具。

参考资料来源：

8、BP神经网络算法的C++源代码可否尽快发一份，825046396@qq.com

#pragma hdrstop
#include
#include
const A=30.0;
const B=10.0;
const MAX=500; //最大训练次数
const COEF=0.0035; //网络的学习效率
const BCOEF=0.001;//网络的阀值调整效率
const ERROR=0.002 ; // 网络训练中的允许误差
const ACCURACY=0.0005;//网络要求精度
double sample[41][4]={{0,0,0,0},{5,1,4,19.020},{5,3,3,14.150},
{5,5,2,14.360},{5,3,3,14.150},{5,3,2,15.390},
{5,3,2,15.390},{5,5,1,19.680},{5,1,2,21.060},
{5,3,3,14.150},{5,5,4,12.680},{5,5,2,14.360},
{5,1,3,19.610},{5,3,4,13.650},{5,5,5,12.430},
{5,1,4,19.020},{5,1,4,19.020},{5,3,5,13.390},
{5,5,4,12.680},{5,1,3,19.610},{5,3,2,15.390},
{1,3,1,11.110},{1,5,2,6.521},{1,1,3,10.190},
{1,3,4,6.043},{1,5,5,5.242},{1,5,3,5.724},
{1,1,4,9.766},{1,3,5,5.870},{1,5,4,5.406},
{1,1,3,10.190},{1,1,5,9.545},{1,3,4,6.043},
{1,5,3,5.724},{1,1,2,11.250},{1,3,1,11.110},
{1,3,3,6.380},{1,5,2,6.521},{1,1,1,16.000},
{1,3,2,7.219},{1,5,3,5.724}};
double w[4][10][10],wc[4][10][10],b[4][10],bc[4][10];
double o[4][10],netin[4][10],d[4][10],differ;//单个样本的误差
double is; //全体样本均方差
int count,a;
void netout(int m, int n);//计算网络隐含层和输出层的输出
void calculd(int m,int n); //计算网络的反向传播误差
void calcalwc(int m,int n);//计算网络权值的调整量
void calcaulbc(int m,int n); //计算网络阀值的调整量
void changew(int m,int n); //调整网络权值
void changeb(int m,int n);//调整网络阀值
void clearwc(int m,int n);//清除网络权值变化量wc
void clearbc(int m,int n);//清除网络阀值变化量bc
void initialw(void);//初始化NN网络权值W
void initialb(void); //初始化NN网络阀值
void calculdiffer(void);//计算NN网络单个样本误差
void calculis(void);//计算NN网络全体样本误差
void trainNN(void);//训练NN网络
/*计算NN网络隐含层和输出层的输出 */
void netout(int m,int n)
{
int i,j,k;
//隐含层各节点的的输出
for (j=1,i=2;j<=m;j++) //m为隐含层节点个数
{
netin[i][j]=0.0;
for(k=1;k<=3;k++)//隐含层的每个节点均有三个输入变量
netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];
netin[i][j]=netin[i][j]-b[i][j];
o[i][j]=A/(1+exp(-netin[i][j]/B));
}
//输出层各节点的输出
for (j=1,i=3;j<=n;j++)
{
netin[i][j]=0.0;
for (k=1;k<=m;k++)
netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];
netin[i][j]=netin[i][j]-b[i][j];
o[i][j]=A/(1+exp(-netin[i][j]/B)) ;
}
}
/*计算NN网络的反向传播误差*/
void calculd(int m,int n)
{
int i,j,k;
double t;
a=count-1;
d[3][1]=(o[3][1]-sample[a][3])*(A/B)*exp(-netin[3][1]/B)/pow(1+exp(-netin[3][1]/B),2);
//隐含层的误差
for (j=1,i=2;j<=m;j++)
{
t=0.00;
for (k=1;k<=n;k++)
t=t+w[i+1][j][k]*d[i+1][k];
d[i][j]=t*(A/B)*exp(-netin[i][j]/B)/pow(1+exp(-netin[i][j]/B),2);
}
}
/*计算网络权值W的调整量*/
void calculwc(int m,int n)
{
int i,j,k;
// 输出层（第三层）与隐含层（第二层）之间的连接权值的调整
for (i=1,k=3;i<=m;i++)
{
for (j=1;j<=n;j++)
{
wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];
}
// printf("\n");
}
//隐含层与输入层之间的连接权值的调整
for (i=1,k=2;i<=m;i++)
{
for (j=1;j<=m;j++)
{
wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];
}
// printf("\n");
}
}
/*计算网络阀值的调整量*/
void calculbc(int m,int n)
{
int j;
for (j=1;j<=m;j++)
{
bc[2][j]=BCOEF*d[2][j];
}
for (j=1;j<=n;j++)
{
bc[3][j]=BCOEF*d[3][j];
}
}
/*调整网络权值*/
void changw(int m,int n)
{
int i,j;
for (i=1;i<=3;i++)
for (j=1;j<=m;j++)
{
w[2][i][j]=0.9*w[2][i][j]+wc[2][i][j];
//为了保证系统有较好的鲁棒性，计算权值时乘惯性系数0.9
printf("w[2][%d][%d]=%f\n",i,j,w[2][i][j]);
}
for (i=1;i<=m;i++)
for (j=1;j<=n;j++)
{
w[3][i][j]=0.9*w[3][i][j]+wc[3][i][j];
printf("w[3][%d][%d]=%f\n",i,j,w[3][i][j]);
}
}
/*调整网络阀值*/
void changb(int m,int n)
{
int j;
for (j=1;j<=m;j++)
b[2][j]=b[2][j]+bc[2][j];
for (j=1;j<=n;j++)
b[3][j]=b[3][j]+bc[3][j];
}
/*清除网络权值变化量wc*/
void clearwc(void)
{
for (int i=0;i<4;i++)
for (int j=0;j<10;j++)
for (int k=0;k<10;k++)
wc[i][j][k]=0.00;
}
/*清除网络阀值变化量*/
void clearbc(void)
{
for (int i=0;i<4;i++)
for (int j=0;j<10;j++)
bc[i][j]=0.00;
}
/*初始化网络权值W*/
void initialw(void)
{
int i,j,k,x;
double weight;
for (i=0;i<4;i++)
for (j=0;j<10;j++)
for (k=0;k<10;k++)
{
randomize();
x=100+random(400);
weight=(double)x/5000.00;
w[i][j][k]=weight;
}
}
/*初始化网络阀值*/
void initialb(void)
{
int i,j,x;
double fazhi;
for (i=0;i<4;i++)
for (j=0;j<10;j++)
{
randomize();
for (int k=0;k<12;k++)
{
x=100+random(400);
}
fazhi=(double)x/50000.00;
b[i][j]=fazhi;
}
}
　/*计算网络单个样本误差*/
void calculdiffer(void)
{
a=count-1;
differ=0.5*(o[3][1]-sample[a][3])*(o[3][1]-sample[a][3]);
}
void calculis(void)
{
int i;
is=0.0;
for (i=0;i<=19;i++)
{
o[1][1]=sample[i][0];
o[1][2]=sample[i][1];
o[1][3]=sample[i][2];
netout(8,1);
is=is+(o[3][1]-sample[i][3])*(o[3][1]-sample[i][3]);
}
is=is/20;
}
/*训练网络*/
void trainNN(void)
{
long int time;
int i,x[4];
initialw();
initialb();
for (time=1;time<=MAX;time++)
{
count=0;
while(count<=40)
{
o[1][1]=sample[count][0];
o[1][2]=sample[count][1];
o[1][3]=sample[count][2];
count=count+1;
clearwc();
clearbc();
netout(8,1);
calculdiffer();
while(differ>ERROR)
{
calculd(8,1);
calculwc(8,1);
calculbc(8,1);
changw(8,1);
changb(8,1);
netout(8,1);
calculdiffer();
}
}
printf("This is %d times training NN...\n",time);
calculis();
printf("is==%f\n",is);
if (is }
}
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
double result;
int m,test[4];
char ch=&＃39;y&＃39;;
cout<<"Please wait for the train of NN:"< trainNN();
cout<<"Now,this modular network can work for you."< while(ch==&＃39;y&＃39; || ch==&＃39;Y&＃39;)
{
cout<<"Please input data to be tested."< for (m=1;m<=3;m++)
cin>>test[m];
ch=getchar();
o[1][1]=test[1];
o[1][2]=test[2];
o[1][3]=test[3];
netout(8,1);
result=o[3][1];
printf("Final result is %f.\n",result);
printf("Still test?[Yes] or [No]\n");
ch=getchar();
}
return 0;
}