当前位置：文档之家 › 神经网络的BP算法C语言实现

神经网络的BP算法C语言实现

  • 格式：docx
  • 大小：14.45 KB
  • 文档页数：8

//BP算法简单实现，C语言代码可运行,详细注释//代码存放文件本文用的绝对路径，会报错，请自行更改路径或者改成相对路径///////////////////////////////////////////#include <stdio.h>#include <math.h>#include <conio.h>#include <stdlib.h>#define input 2 //输入层#define hidden 10 //隐层#define output 1 //输出层#define sampleNum 90 //样本容量#define test 10 //测试集容量#define nr 0.1 //学习效率#define EPS 0.00001floatx[sampleNum][input],d[sampleNum][output],whi[input][hidden],wij[hidden][output],thi[hidden] ,thj[output];//x是输入的值，d是输出的值，whi是权值，int h,i,j,k,ff;double testdata[1][2];float xmin[input],xmax[input],dmin[output],dmax[output];FILE *fp1,*fp2,*fp3,*fp4;void init(void);void startleaning(void);void testsample(void);void readw(void);void readt(void);void writew(void);float sigmoid(float a);double ranu(void);void init(void){int min,max;if(fp1==0){system("cls");printf("Can not find the learning sample file!\n");exit(0);}for(k=0;k<sampleNum;k++){for(h=0;h<input;h++)fscanf(fp1,"%f,",&x[k][h]); //神经网络输入for(j=0;j<output;j++)fscanf(fp1,"%f,",&d[k][j]); //神经网络输出}for(j=0;j<output;j++){min=1;max=1;for(k=0;k<sampleNum;k++){if(d[k][j]<d[min][j])min=k;if(d[k][j]>d[max][j])max=k;}dmin[j]=d[min][j];dmax[j]=d[max][j];for(k=0;k<sampleNum;k++) //神经网络输出归一化d[k][j]=(d[k][j]-dmin[j])/(dmax[j]-dmin[j]);}}void startlearning(void){long int nt,n;floatt,error[sampleNum],gerror,xj[output],xi[hidden],yj[output],yi[hidden],pxi[hidden],pxj[output]; float u0=0,u1=0,u2=0,u3=0;float v0,v1,v2,v3;for(i=0;i<hidden;i++){for(h=0;h<input;h++)whi[h][i]=-0.8+1.6*ranu(); //whi为输入到隐藏层的权值for(j=0;j<output;j++)wij[i][j]=-0.8+1.6*ranu(); //wij为隐藏层到输出的权值thi[i]=-0.5+ranu(); //thi为输入到隐藏层的bias}for(j=0;j<output;j++)thj[j]=-0.5+ranu(); //thj为隐藏层到输出的bias//学习开始printf("\t\nPlease enter the learning times:\n");scanf("%ld",&nt);for(n=0;n<nt;n++) /*nt为学习次数*/{gerror=0;for(k=0;k<sampleNum;k++) /*单样本循环*/{for(i=0;i<hidden;i++){t=0;for(h=0;h<input;h++)t+=whi[h][i]*x[k][h];xi[i]=t+thi[i]; //xi为输入层到隐藏层的权值和yi[i]=sigmoid(xi[i]); //yi为函数变换后的输出层//隐层输出}for(j=0;j<output;j++){t=0;for(i=0;i<hidden;i++)t+=wij[i][j]*yi[i];xj[j]=t+thj[j]; //xj为隐藏层到输出层的权值和yj[j]=sigmoid(xj[j]); //yj为函数变换后的输出层} //输出层输出for(j=0;j<output;j++) //pxj为输出层单样本点误差变化率pxj[j]=yj[j]*(1-yj[j])*(yj[j]-d[k][j]);for(i=0;i<hidden;i++) //pxi为隐层单样本点误差变化率{t=0;for(j=0;j<output;j++)t+=pxj[j]*wij[i][j];pxi[i]=yi[i]*(1-yi[i])*t;}for(j=0;j<output;j++){thj[j]=thj[j]-nr*pxj[j];for(i=0;i<hidden;i++){wij[i][j]=wij[i][j]-nr*pxj[j]*yi[i]; //隐层到输出层权值修正，其中nr为步长 }}for(i=0;i<hidden;i++){thi[i]=thi[i]-nr*pxi[i];for(h=0;h<input;h++){whi[h][i]=whi[h][i]-nr*pxi[i]*x[k][h]; //输入层到隐层权值修正，其中nr为步长 }}t=0;for(j=0;j<output;j++)t+=(yj[j]-d[k][j])*(yj[j]-d[k][j])/2.0;error[k]=t;gerror+=error[k]; //全局误差 g(lobal)error}//单样本循环结束if(gerror<EPS)break;}writew();fclose(fp2);int k=0;for(k=0;k<sampleNum;k++){for(i=0;i<hidden;i++){t=0;for(h=0;h<input;h++)t+=whi[h][i]*x[k][h];xi[i]=t+thi[i]; //xi为输入层到隐藏层的权值和yi[i]=sigmoid(xi[i]); //yi为函数变换后的输出层//隐层输出}for(j=0;j<output;j++){t=0;for(i=0;i<hidden;i++)t+=wij[i][j]*yi[i];xj[j]=t+thj[j]; //xj为隐藏层到输出层的权值和yj[j]=sigmoid(xj[j]); //yj为函数变换后的输出层}printf("%f %f %f\n",x[k][0],x[k][1],yj[0]*(dmax[0]-dmin[0])+dmin[0]);}while(1){printf("press any number to test Network,press 'C' exit to use test.txt\n");scanf("%lf%lf",&testdata[0][0],&testdata[0][1]);if(getchar()=='c') break;for(i=0;i<hidden;i++){t=0;for(h=0;h<input;h++)t+=whi[h][i]*testdata[0][h];xi[i]=t+thi[i]; //xi为输入层到隐藏层的权值和yi[i]=sigmoid(xi[i]); //yi为函数变换后的输出层//隐层输出}for(j=0;j<output;j++){t=0;for(i=0;i<hidden;i++)t+=wij[i][j]*yi[i];xj[j]=t+thj[j]; //xj为隐藏层到输出层的权值和yj[j]=sigmoid(xj[j]); //yj为函数变换后的输出层}printf("test:%f\n",yj[0]*(dmax[0]-dmin[0])+dmin[0]);}// 学习循环结束for(i=0;i<hidden;i++){for(h=0;h<input;h++)printf("W(input->hidden)[%d][%d]=%f\n",h,i,whi[h][i]);}for(i=0;i<hidden;i++){for(j=0;j<output;j++)printf("W(hidden->output)[%d][%d]=%f\n",i,j,wij[i][j]);}for(i=0;i<hidden;i++)printf("bias(input->hidden)[%d]=%f\n",i,thi[i]);for(j=0;j<output;j++)printf("bias(hidden->output)[%d]=%f\n",j,thj[j]);printf("\t\nGlobal error=%f\n",gerror);printf("Press any key to choose a next task!/n");getch();}void testsample(void){float tx[input],t,xj[output],xi[hidden],yj[output],yi[hidden];if(fp2==0){printf("\t can not find the weight \n");exit(0);}readw();for(ff=0;ff<test;ff++){for(h=0;h<input;h++)fscanf(fp3,"%f,",&tx[h]);for(i=0;i<hidden;i++){t=0;for(h=0;h<input;h++)t+=whi[h][i]*tx[h];xi[i]=t+thi[i];yi[i]=sigmoid(xi[i]);}for(j=0;j<output;j++){t=0;for(i=0;i<hidden;i++)t+=wij[i][j]*yi[i];xj[j]=t+thj[j];yj[j]=sigmoid(xj[j]);}for(j=0;j<output;j++){yj[j]=yj[j]*(dmax[j]-dmin[j])+dmin[j];fprintf(fp4,"%f\n",yj[j]);}}fclose(fp4);printf("\t\nThe result save in testreslut.txt?\n"); printf("Press any key to choose a next task!\n"); getch();}void writew(void){rewind(fp2);for(h=0;h<input;h++){for(i=0;i<hidden;i++)fprintf(fp2,"%8.3f ",whi[h][i]);fprintf(fp2,"\n");}fprintf(fp2,"\n");for(i=0;i<hidden;i++)fprintf(fp2,"%8.3f ",thi[i]);fprintf(fp2,"\n\n");for(j=0;j<output;j++){for(i=0;i<hidden;i++)fprintf(fp2,"%8.3f ",wij[i][j]);fprintf(fp2,"\n");}fprintf(fp2,"\n");for(j=0;j<output;j++)fprintf(fp2,"%8.3f ",thj[j]);}void readw(void){for(h=0;h<input;h++)for(i=0;i<hidden;i++)fscanf(fp2,"%f",&whi[h][i]);for(i=0;i<hidden;i++)fscanf(fp2,"%f",&thi[i]);for(j=0;j<output;j++)for(i=0;i<hidden;i++)fscanf(fp2,"%f",&wij[i][j]);for(j=0;j<output;j++)fscanf(fp2,"%f",&thj[j]);}float sigmoid(float a){return (1.0/(1+exp(-a)));}double ranu(void){static double xrand=3.0;double m=8589934592.0, a=30517578125.0; lp: xrand=fmod(xrand*a,m); /*整除取余*/ if(xrand>1.0)return(xrand/m);else{xrand=1.0;goto lp;}}void main(){fp1=fopen("D:/BP/sample.txt","r");fp2=fopen("D:/BP/weight.txt","w+");fp3=fopen("D:/BP/test.txt","r+");fp4=fopen("D:/BP/testreslut.txt","w+");init();while(1){system("cls");printf("\t\n choose a task...\n\n");printf("\t\n (S) Press 'S' Start Learning.\n"); printf("\t\n (T) Press 'T' Test Samples.\n"); printf("\t\n (Q) Press 'Q' quit!\n");switch(getchar()){case 's': startlearning();break;case 't': testsample();break;case 'q': exit(0);break;}}fclose(fp1);fclose(fp3);getch();}。

合集下载

bp神经网络详细步骤C实现

bp神经网络详细步骤C实现

e+=(yd[k]-x2[k])*(yd[k]-x2[k]);
//更新V，V矩阵是隐藏层与输出层之间的权值for(intj=0;j<hideNum;j++)
{
v[j,k]+=rate*qq[k]*x1[j];
}
}
//计算隐层误差
for(intj=0;j<hideNum;j++)
{
//PP矩阵是隐藏层的误差
{
//★数据归一化
for(inti=0;i<inNum;i++)
{
x[i]=p[isamp,i]/in_rate;
}
for(inti=0;i<outNum;i++)
{
yd[i]=t[isamp,i]/in_rate;
}
//计算隐层的输入和输出
for(intj=0;j<hideNum;j++)
{
o1[j]=0.0;
{
w[i]+=dw[i];
}
}
//数据仿真函数
publicdouble[]sim(double[]psim)
{
for(i nti=O;i<i nN um;i++)
x[i]=psim[i]/in_rate;//in_rate为归一化系数
for(i ntj=O;j<hideNum;j++)
{
o1[j]=0.0；
{pMax=Math.Abs(p[isamp,i]);
}
}for(intj=0;j<outNum;j++)
{if(Math.Abs(t[isamp,j])>pMax)
如何用C语言编程实现多层前向BP神经网络,用来解决逻辑 XOR 运算和奇偶检验问题

如何用C语言编程实现多层前向BP神经网络,用来解决逻辑 XOR 运算和奇偶检验问题

6.（ 1） 试用 C 语言编程实现多层前向 NN 的 BP 算法。

要求：输入、输出结点数目，隐层数目，及各隐层中结点的数目应为任意整数。

（ 2） 试用所编出的 BP 算法程序训练出一个实现 XOR 运算的 2 层前向网络。

（ 3） 用所编出的 BP 算法程序训练出输入矢量的维数分别为 n=7和 n=8的两个实现奇偶检验运算（即如题 2.(2)所述）的 2 层前向 NN 。

注： 对第 6 题的要求：(i) 列表给出训练收敛后的 NN 权值和所用的迭代次数；(ii) 给出训练收敛后的训练误差和检验误差，及用训练集和检验集做输入时所得到的正确输出率；(iii) 给出 NN 的学习曲线（即 E(W(k))随迭代次数 k 的变化曲线，该结果应是用计算程序计算和打印出来的曲线，而不要是用手画出的曲线）。

（1）用C 语言编程实现前向NN 的BP 算法 解：解题思路：先用 C 语言编程实现前向 NN 的 BP 算法，再将误差保存至文本文件，最后用MATLAB 绘制出误差曲线。

（1.1）开发思路奇偶检验问题可视为 XOR 问题的推广（由 2 输入到 n 输入的推广）：若 n 个输入中有奇数个1，则输出为 1；若n 个输入中有偶数个1，则输出为 0。

一个 2 层的 NN 可实现奇偶检验运算。

本文选用2层神经网络，包括隐含层1层，输出层1层，来设计BP 神经网络。

x 1x 2x n2层神经网络本文隐含层和输出层的激活函数选用Sigmoid 函数，1()1ss eϕ-=+，()(1())d s s ds ϕϕϕ=- 其函数曲线如下所示：由奇偶检验问题的定义： 可定义如下分类函数：1 y>=1/2Y()0 y<1/2y ⎧=⎨⎩其中y 为BP 神经网络的输出值，Y 为分类结果。

（1.2）运行流程本文的多层前向 NN 的 BP 算法用C 语言编程实现，最后将运行结果保存成数据文件，通过MATLAB绘图显示，其运行流程图如上图所示，其源代码见附录部分。

Bp神经网络+C++实现

Bp神经网络+C++实现

Bp神经网络+C++实现0 前言神经网络在我印象中一直比较神秘，正好最近学习了神经网络，特别是对Bp神经网络有了比较深入的了解，因此，总结以下心得，希望对后来者有所帮助。

神经网络在机器学习中应用比较广泛，比如函数逼近，模式识别，分类，数据压缩，数据挖掘等领域。

神经网络本身是一个比较庞大的概念，从网络结构类别来划分，大概有：多层前馈神经网络、径向基函数网络（RBF）、自适应谐振理论网络（ART）、自组织映射网络（SOM）、级联相关网络、Elman网络、Boltzmann机、受限Boltzmann机等等。

下面一张图是最近比较流行的网络结构：今天我们要介绍的是Bp神经网络，准确的说是采用Bp算法进行训练的多层前馈神经网络，Bp算法应用比较广泛。

1基本概念：1.1神经元模型机器学习中所谈论的神经网络源于生物上的神经网络，实际上指的是“神经网络“与”机器学习“的交叉部分，一个最简单的M-P神经元模型如下图所示：该神经元收到来自其他n个输入神经元传递过来的输入信号（加权和的形式），然后将其与神经元的阈值进行比较，通过激活函数进行处理，产生神经元的输出。

1.2 常用激活函数激活函数的作用是对其他所有神经元传过来的所有信号加权和进行处理，产生神经元输出。

下图是常用的激活函数，最简单的是：阶跃函数，它简单，最理想，但是性质最差（不连续/不光滑），因此在实际中，最常用的是Sigmoid函数。

1.3前馈神经网络多层前馈神经网络的准确定义：每一层神经元与下一层神经元全互连，神经元之间不存在同层连接，不存在跨层连接，如下图所示就是一个经典的前馈神经网络，（随便插一句，当神经网络中隐层数越来越多，达到8-9层时，就变成了一个深度学习模型，我曾在一篇论文中看到网络结构有达128层的，关于下面这块，下面还会再叙述）。

2.标准Bp算法2.0 关于梯度首先我们应该清楚，一个多元函数的梯度方向是该函数值增大最陡的方向。

具体化到1元函数中时，梯度方向首先是沿着曲线的切线的，然后取切线向上增长的方向为梯度方向，2元或者多元函数中，梯度向量为函数值f对每个变量的导数，该向量的方向就是梯度的方向，当然向量的大小也就是梯度的大小。

改进地BP神经网络算法C语言源码

改进地BP神经网络算法C语言源码

#include "stdio.h"#include "stdlib.h"#include "time.h"#include "math.h"/*********************************************inpoints 为输入神经元个数，可改变outpoints为输出神经元个数defaultpoints为隐层神经元个数datagrough为样本数据个数****************************************************以下数据定义可以修改*****/#define A 0#define a 1#define b 1#define c 1#define ALFA 0.85#define BETA 0.2 //学习率0~1#define Total 20000#define inpoints 9#define outpoints 5#define defaultpoints 28#define datagrough 44#define forecastdata 4/**********定义所需变量********/double InpointData[datagrough][inpoints],OutpointData[datagrough][outpoints]; /* 输入输出数据 */double InpointData_MAX[inpoints],InpointData_MIN[inpoints]; /* 每个因素最大数据 */double OutpointData_MAX[outpoints],OutpointData_MIN[outpoints]; /* 每个因素最小数据 */doublew[defaultpoints][inpoints],limen[defaultpoints],v[outpoints][defaultpoints]; /* 连接权值、阈值 */doubledlta_w[defaultpoints][inpoints],dlta_limen[defaultpoints],dlta_v[outpoints][defaultpoints]; /* 连接权、阈值修正值 */doubledefaultOutpoint[defaultpoints],Outpoint_dp[outpoints],Outpoint_ep[datagrough];/**************************读数据文件******************************/void ReadData(){FILE *fp1,*fp2;int i,j;if((fp1=fopen("D:\\data\\训练输入.txt","r"))==NULL){printf("1can not open the file\n");exit(0);}for(i=0;i<datagrough;i++)for(j=0;j<inpoints;j++)fscanf(fp1,"%lf",&InpointData[i][j]);fclose(fp1);if((fp2=fopen("D:\\data\\训练输出.txt","r"))==NULL){printf("2can not open the file\n");exit(0);}for(i=0;i<datagrough;i++)for(j=0;j<outpoints;j++)fscanf(fp2,"%lf",&OutpointData[i][j]);fclose(fp2);}/*****************************************************//*****************************************归一化******************************************************/void unitary(){int i,j;int k=0;for(j=0;j<inpoints;j++) //找出每列的最大、最小值存放在数组InpointData_MAX[j]、InpointData_MIN[j]中{InpointData_MAX[j]=InpointData[0][j];InpointData_MIN[j]=InpointData[0][j];for(i=0;i<datagrough;i++)if(InpointData_MAX[j]<InpointData[i][j])InpointData_MAX[j]=InpointData[i][j];else if(InpointData_MIN[j]>InpointData[i][j])InpointData_MIN[j]=InpointData[i][j];}for(j=0;j<outpoints;j++) //找出每列的最大、最小值存放在数组OutpointData_MAX[j]、OutpointData_MIN[j]中{OutpointData_MAX[j]=OutpointData[0][j];OutpointData_MIN[j]=OutpointData[0][j];for(i=0;i<datagrough;i++)if(OutpointData_MAX[j]<OutpointData[i][j])OutpointData_MAX[j]=OutpointData[i][j];else if(OutpointData_MIN[j]>OutpointData[i][j])OutpointData_MIN[j]=OutpointData[i][j];}/***************将数据归一处理,处理之后的数据全部在[0，1]之间*************************/for(j=0;j<inpoints;j++)for(i=0;i<datagrough;i++)if(InpointData_MAX[j]==0)InpointData[i][j]=0;elseInpointData[i][j]=(InpointData[i][j]-InpointData_MIN[j]+A)/(InpointData_MAX[j]-InpointData_MIN[j]+A);for(j=0;j<outpoints;j++)for(i=0;i<datagrough;i++)if(OutpointData_MAX[j]==0)OutpointData[i][j]=0;elseOutpointData[i][j]=(OutpointData[i][j]-OutpointData_MIN[j]+A)/(OutpointData_MAX [j]-OutpointData_MIN[j]+A);}/*****************************************************//*********************初始化，随机赋初值**************************/void Initialization(){int i,j;srand((unsigned)time(NULL)); //头文件名 #include <time.h>for(i=0;i<defaultpoints;i++) //给输入层到隐层的连接权赋随机值LianJie_w[i][j],这些值在[0,1]for(j=0;j<inpoints;j++){w[i][j]=(rand()*2.0/RAND_MAX-1)/2;dlta_w[i][j]=0;}for(i=0;i<defaultpoints;i++){limen[i]=(rand()*2.0/RAND_MAX-1)/2;dlta_limen[i]=0;}for(i=0;i<outpoints;i++) //给隐层到输出层的连接权赋初值for(j=0;j<defaultpoints;j++){v[i][j]=(rand()*2.0/RAND_MAX-1)/2;dlta_v[i][j]=0;}}/**********************求单样本的计算输出误差*******************************/ void out_sub1(int t){int i,j;double defaultInpoint[defaultpoints];double Outpoint_y[outpoints];Outpoint_ep[t]=0;for(i=0;i<defaultpoints;i++){double sum=0;for(j=0;j<inpoints;j++)sum+=w[i][j]*InpointData[t][j];defaultInpoint[i]=sum+limen[i];defaultOutpoint[i]=1/(a+b*exp(-1*c*defaultInpoint[i]));//求O[i] }for(j=0;j<outpoints;j++)//求Y[i]{Outpoint_y[j]=0;for(i=0;i<defaultpoints;i++)Outpoint_y[j]+=v[j][i]*defaultOutpoint[i];Outpoint_dp[j]=OutpointData[t][j]-Outpoint_y[j];Outpoint_ep[t]+=Outpoint_dp[j]*Outpoint_dp[j]/2;}}/*****************************反算权值******************************************/void out_sub2(int t){int i,j,k;double s;for(i=0;i<defaultpoints;i++){s=0;for(j=0;j<outpoints;j++){dlta_v[j][i]=ALFA*dlta_v[j][i]+BETA*Outpoint_dp[j]*defaultOutpoint[i]; //s+=v[j][i]*Outpoint_dp[j];v[j][i]+=dlta_v[j][i];}dlta_limen[i]=ALFA*dlta_limen[i]+BETA*defaultOutpoint[i]*(1-defaultOutpoint[i]) *s;//limen[i]+=dlta_limen[i];for(k=0;k<inpoints;k++){dlta_w[i][k]=ALFA*dlta_w[i][k]+BETA*defaultOutpoint[i]*(1-defaultOutpoint[i])*s *InpointData[t][k];//w[i][k]=w[i][k]+dlta_w[i][k];}}}/*******************************************************/void forecast(){int i,j,t,k=0;double e,e1[forecastdata]={0}; //训练误差double sss;double InputData_x[forecastdata][inpoints],tp[forecastdata][outpoints];doubledefInpoint,defOutpoint[defaultpoints],y[forecastdata][outpoints];//y[forecastda ta][outpoints]为网络检验输出FILE *fp1,*fp3;if((fp1=fopen("D:\\data\\预测输入.txt","r"))==NULL) //检验数据输入{printf("3can not open the file\n");exit(0);}for(i=0;i<forecastdata;i++)for(j=0;j<inpoints;j++)fscanf(fp1,"%lf",&InputData_x[i][j]);fclose(fp1);if((fp3=fopen("D:\\data\\预测输出.txt","r"))==NULL) //实际检验结果输出{printf("31can not open the file\n");exit(0);}for(i=0;i<forecastdata;i++)for(j=0;j<outpoints;j++)fscanf(fp3,"%lf",&tp[i][j]);fclose(fp3);for(j=0;j<inpoints;j++) // 检验数据归一化for(i=0;i<forecastdata;i++)if(InpointData_MAX[j]==0)InputData_x[i][j]=0;elseInputData_x[i][j]=(InputData_x[i][j]-InpointData_MIN[j]+A)/(InpointData_MAX[j]-InpointData_MIN[j]+A);for(j=0;j<outpoints;j++)for(i=0;i<forecastdata;i++)if(OutpointData_MAX[j]==0)tp[i][j]=0;elsetp[i][j]=(tp[i][j]-OutpointData_MIN[j]+A)/(OutpointData_MAX[j]-OutpointData_MIN [j]+A);do{Initialization(); //初始化连接权值w[i][j],limen[i],v[k][i]k=0;do{e=0;for(t=0;t<datagrough;t++){out_sub1(t); //正向计算网络输出out_sub2(t); //反向计算，修正权值e+=Outpoint_ep[t]; //计算输出误差}k++;}while((k<Total)&&(e>0.1));sss=0; //中间参数for(t=0;t<forecastdata;t++){e1[t]=0;for(i=0;i<defaultpoints;i++){double sum=0;for(j=0;j<inpoints;j++)sum+=w[i][j]*InputData_x[t][j];defInpoint=sum+limen[i];defOutpoint[i]=1/(a+b*exp(-1*c*defInpoint));}for(j=0;j<outpoints;j++){y[t][j]=0;for(i=0;i<defaultpoints;i++)y[t][j]+=v[j][i]*defOutpoint[i];e1[t]+=(y[t][j]-tp[t][j])*(y[t][j]-tp[t][j])/2;y[t][j]=y[t][j]*(OutpointData_MAX[j]-OutpointData_MIN[j]+A)+OutpointData_MI N[j]-A;}sss+=e1[t];}sss=sss/forecastdata;printf(" %lf %lf\n",e,sss);}while(sss>0.12);}/********************************************************/void main(){int i,j,k;FILE *fp2;ReadData(); //读训练数据：输入和输出unitary(); //归一化，将输入输出数据归一，结果在[0，1]中forecast(); //检验误差if((fp2=fopen("D:\\data\\计算权值.txt","w"))==NULL) //文件输出训练好的权值{printf("6can not open the file\n");exit(0);}for(i=0;i<defaultpoints;i++){for(k=0;k<inpoints;k++)fprintf(fp2," %lf ",w[i][k]);fprintf(fp2,"\n");}fprintf(fp2,"\n");for(i=0;i<defaultpoints;i++)fprintf(fp2," %lf ",limen[i]);fprintf(fp2,"\n\n");for(i=0;i<defaultpoints;i++){for(j=0;j<outpoints;j++)fprintf(fp2," %lf ",v[j][i]);fprintf(fp2,"\n");}fclose(fp2);}。