实验四 BP神经网络模拟sin函数.docx

实验四 BP神经网络模拟sin函数.docx

《实验四 BP神经网络模拟sin函数.docx》由会员分享，可在线阅读，更多相关《实验四 BP神经网络模拟sin函数.docx（14页珍藏版）》请在冰豆网上搜索。

实验四BP神经网络模拟sin函数

实验四BP神经网络模拟sin函数

一、问题描述

BP神经网络模拟sin函数

根据人工神经网络学习算法，实现正弦曲线的拟合。

要求能随机自动生成数量为n的正弦值作为训练集，并根据训练集拟合曲线，最后能通过输入x值测试理论与拟合sinx的拟合度。

二、设计思想

思维学普遍认为，人类大脑的思维分为抽象（逻辑）思维、形象（直观）思维和灵感（顿悟）思维三种基本方式。

逻辑性的思维是指根据逻辑规则进行推理的过程；它先将信息化成概念，并用符号表示，然后，根据符号运算按串行模式进行逻辑推理；这一过程可以写成串行的指令，让计算机执行。

然而，直观性的思维是将分布式存储的信息综合起来，结果是忽然间产生想法或解决问题的办法。

这种思维方式的根本之点在于以下两点:

1.信息是通过神经元上的兴奋模式分布储在网络上;2.信息处理是通过神经元之间同时相互作用的动态过程来完成的。

人工神经网络就是模拟人思维的第二种方式。

这是一个非线性动力学系统，其特色在于信息的分布式存储和并行协同处理。

虽然单个神经元的结构极其简单，功能有限，但大量神经元构成的网络系统所能实现的行为却是极其丰富多彩的。

人工神经网络由大量的神经元构成。

这些神经元一般分为三种：

输入层神经元，隐层神经元和输出层神经元。

输入层：

单元i的输入：

单元数量：

d

单元i的输出：

单元i的激活函数：

线性函数

隐层：

单元j的输入：

单元数量：

单元j的输出：

单元j的激活函数：

非线性函数

输出层：

单元k的输入：

单元数量：

c

单元k的输出：

单元k的激活函数：

非线性函数

3、程序设计

1、编译环境

使用C#语言编写，编译器为VS2008，运行环境为Windows+.NetFramework3.5

2、程序运行流程

运行程序后，单击“训练”按钮，开始训练，训练完成后可以看到函数图像与各权值，输入x的值可以查看预测值与准确值。

3、类设计

神经网络类的定义：

classNeuralNetwork

{

#regionInstanceFields

//privatefields

privateintnum_in;

privateintnum_hid;

privateintnum_out;

privatedouble[,]i_to_h_wts;

privatedouble[,]h_to_o_wts;

privatedouble[]inputs;

privatedouble[]hidden;

privatedouble[]outputs;

privatedoublelearningRate=0.3;

privateRandomgen=newRandom（）;

#endregion

#regionConstructor

///

///Numberofinputsnodes

///Numberofhiddennodes

///Numberofoutputnodes

publicNeuralNetwork（intnum_in,intnum_hid,intnum_out）

{

this.num_in=num_in;

this.num_hid=num_hid;

this.num_out=num_out;

i_to_h_wts=newdouble[num_in+1,num_hid];

h_to_o_wts=newdouble[num_hid+1,num_out];

inputs=newdouble[num_in+1];

hidden=newdouble[num_hid+1];

outputs=newdouble[num_out];

}

#endregion

#regionInitializationofrandomweights

///

publicvoidinitialiseNetwork（）

{

//Settheinputvalueforbiasnode

inputs[num_in]=1.0;

hidden[num_hid]=1.0;

//Setweightsbetweeninput&hiddennodes.

for（inti=0;i

{

for（intj=0;j

{

//Setrandomweightsbetween-2&2

i_to_h_wts[i,j]=（gen.NextDouble（）*4）-2;

}

}

//Setweightsbetweenhidden&outputnodes.

for（inti=0;i

{

for（intj=0;j

{

//Setrandomweightsbetween-2&2

h_to_o_wts[i,j]=（gen.NextDouble（）*4）-2;

}

}

}

#endregion

#regionPassforward

///

///Andouble[]arraywhichholdsinputvalues,which

///arethenpresetedtothenetworksinputlayer

publicvoidpass_forward（double[]applied_inputs）

{

//Loadasetofinputsintoourcurrentinputs

for（inti=0;i

{

inputs[i]=applied_inputs[i];

}

//Forwardtohiddennodes,andcalculateactivationsinhiddenlayer

for（inti=0;i

{

doublesum=0.0;

for（intj=0;j

{

sum+=inputs[j]*i_to_h_wts[j,i];

}

hidden[i]=ActivationFunction.Sigmoid（sum）;

}

//Forwardtooutputnodes,andcalculateactivationsinoutputlayer

for（inti=0;i

{

doublesum=0.0;

for（intj=0;j

{

sum+=hidden[j]*h_to_o_wts[j,i];

}

//passthesum,throughtheactivationfunction,Sigmoidinthiscase

//whichallowsforbackwarddifferentation

outputs[i]=ActivationFunction.Sigmoid（sum）;

}

}

#endregion

#regionPublicProperties

///

publicintNumberOfInputs

{

get{returnnum_in;}

set{num_in=value;}

}

///

publicintNumberOfHidden

{

get{returnnum_hid;}

set{num_hid=value;}

}

///

publicintNumberOfOutputs

{

get{returnnum_out;}

set{num_out=value;}

}

///

publicdouble[,]InputToHiddenWeights

{

get{returni_to_h_wts;}

set{i_to_h_wts=value;}

}

///

publicdouble[,]HiddenToOutputWeights

{

get{returnh_to_o_wts;}

set{h_to_o_wts=value;}

}

///

publicdouble[]Inputs

{

get{returninputs;}

set{inputs=value;}

}

///

publicdouble[]Hidden

{

get{returnhidden;}

set{hidden=value;}

}

///

publicdouble[]Outputs

{

get{returnoutputs;}

set{outputs=value;}

}

///

publicdoubleLearningRate

{

get{returnlearningRate;}

set{learningRate=value;}

}

#endregion

}

训练过程：

publicvoidTrain（）

{

_nn.initialiseNetwork（）;

for（inti=0;i

{

foreach（TrainSettrainSetin_trainSets）

{

double[]inputs=newdouble[]{trainSet.Input};

double[]outputs=newdouble[]{trainSet.Output};

_nn.pass_forward（inputs）;

train_network（outputs）;

}

}

}

权值变更函数：

privatevoidtrain_network（double[]outputs）

{

//getmomentumvalues（deltavaluesfromlastpass）

double[]delta_hidden=newdouble[_nn.NumberOfHidden+1];

double[]delta_outputs=newdouble[_nn.NumberOfOutputs];

//Getthedeltavaluefortheoutputlayer

for（inti=0;i<_nn.NumberOfOutputs;i++）

{

delta_outputs[i]=

_nn.Outputs[i]*（1.0-_nn.Outputs[i]）*（outputs[i]-_nn.Outputs[i]）;

}

//Getthedeltavalueforthehiddenlayer

for（inti=0;i<_nn.NumberOfHidden+1;i++）

{

doubleerror=0.0;

for（intj=0;j<_nn.NumberOfOutputs;j++）

{

error+=_nn.HiddenToOutputWeights[i,j]*delta_outputs[j];

}

delta_hidden[i]=_nn.Hidden[i]*（1.0-_nn.Hidden[i]）*error;

}

//Nowupdatetheweightsbetweenhidden&outputlayer

for（inti=0;i<_nn.NumberOfOutputs;i++）

{

for（intj=0;j<_nn.NumberOfHidden+1;j++）

{

//usemomentum（deltavaluesfromlastpass）,

//toensuremovedincorrectdirection

_nn.HiddenToOutputWeights[j,i]+=_nn.LearningRate*delta_outputs[i]*_nn.Hidden[j];

}

}

//Nowupdatetheweightsbetweeninput&hiddenlayer

for（inti=0;i<_nn.NumberOfHidden;i++）

{

for（intj=0;j<_nn.NumberOfInputs+1;j++）

{

//usemomentum（deltavaluesfromlastpass）,

//toensuremovedincorrectdirection

_nn.InputToHiddenWeights[j,i]+=_nn.LearningRate*delta_hidden[i]*_nn.Inputs[j];

}

}

}

激活函数（sigmoid函数）：

publicstaticdoubleSigmoid（doublex）

{

return1.0/（1.0+Math.Pow（Math.E,-x））;

}

建立训练集和输入层，隐层，输出层分别为1，4，1的神经网络实例：

TrainSet[]set=newTrainSet[setSize];

for（inti=0;i

{

doublen=Math.PI*2/setSize;

set[i]=newTrainSet（n*（i+1）,Math.Sin（n*（i+1））/2+0.5）;

}NeuralNetworknetwork=newNeuralNetwork（1,4,1）;

绘制拟合后的图形：

Graphicsg;

g=panel1.CreateGraphics（）;

g.Clear（panel1.BackColor）;

doublepi=Math.PI*2/setSize;

for（inti=0;i

{

g.FillRectangle（brush,（float）（pi*（i+1））*40,100-（float）（_nntrainer.GetOutPut（newdouble[]{pi*（i+1）}）[0]）*100,1,1）;

}

输出任意角度的拟合值和正弦值：

double_result=_nntrainer.GetOutPut（newdouble[]{Double.Parse（x_value.Text）}）[0];

result.Text=（（_result-0.5）*2）.ToString（）;

sinx.Text=Math.Sin（Double.Parse（x_value.Text））.ToString（）;

4、程序运行截图

1、程序界面

2、训练结果

3、对比预测值与准确值