if（arr[i]==a）{
temp=1;
break;
}
}
if（temp==1）returntrue;//如果在则返回true
elsereturnfalse;
}
publicvoidinit_weight（）{//初始化各层神经元的权值
inti,j=0,k;
weight=newdouble[30];
for（i=0;i<30;i++）{
weight[i]=Math.random（）;
while（isInarr（weight,i,weight[i]））{//使初始化的各个权值各不相同
weight[i]=Math.random（）;
}
}
vc1=newVector>（4）;//向量
vc2=newVector>（3）;
vc3=newVector>
（2）;
for（i=0;i<4;i++）{//存放第一层的权值
for（k=0;k<3;k++）{
vc11.add（weight[j++]）;//末尾增加double
}
vc1.add（vc11）;//增加向量
}
for（i=0;i<3;i++）{//存放第二层的权值
Vectorvc22=newVector（4）;
for（k=0;k<4;k++）{
vc22.add（weight[j++]）;
}
vc2.add（vc22）;
}
for（i=0;i<2;i++）{//存放第三层的权值
Vectorvc33=newVector（3）;
for（k=0;k<3;k++）{
vc33.add（weight[j++]）;
}
vc3.add（vc33）;
}
}
publicvoidoutput（doubleaa[]）{//根据输入向量aa产生最后的输岀，三层的输岀
doublex1,x2,x3;
intj=0;
x1=aa[0];
x2=aa[1];
x3=aa[2];
for（j=0;j<4;j++）{//计算input[],in_output[]〃三个输入乘以权值的相加
input[j]=
x1*（（（Vector）vc1.get（j））.get（0））.doubleValue（）+
vc1.get（j））.get
（1））.doubleValue（）+vc1.get（j））.get
（2））.doubleValue（）;
pow（Math.E,-input[j]））;//s形函数
}
for（j=0;j<3;j++）{//计算hidden」n[],hidden_output[]
hidden」n[j]=
in_output[0]*（（（Vector）vc2.get（j））.get（0））.doubleValue（）+
in_output
[1]*（（（Vector）
vc2
.get（j））.get
（1））.doubleValue（）+
in_output
[2]*（（（Vector）
vc2
.get（j））.get
（2））.doubleValue（）+
in_output
[3]*（（（Vector）
vc2
.get（j））.get（3））.doubleValue（）;
hidden_output[j]=1/（1+Math.pow（Math.E,-hidden_in[j]））;
vc3.get（j））.get（0））.doubleValue（）+
for（j=0;j<2;j++）{o_in[j]=hidden_output[0]*（（（Vector）
hidden_output
[1]*（（（Vector）
vc3.get（j））.get
（1））.doubleValue（）+
vc3.get（j））.get
（2））.doubleValue（）;pow（Math.E,-o_in[j]））;
public
岀output1[]
double计算输岀误差
calculate_ep（
doubleoutput1[],intn）{//根据第n个样本的实际输
doubleexpect[]=（
double[]）
（（（Vector）sa.hashmap.get（n））.get
（1））;doubleep1;
ep1=
（Math.
3公式
pow（output1[0]-expect[0],2）+Math.
pow（output1[1]-expect[1],2））/2;
//7-1
returnep1;
intn）{//根据第n个样本来调整输出
publicdouble[]adjust_outputlevel_weight（层的权值根据7-15
doubleoutput_error[]=
newdouble[2];
//用于存放输出层每个神经元的输出
误差
doubletemp[]=（double
[]）（（Vector）sa.hashmap.get（n））.get
（1）;Vectorvctemp=newVector（）;
doubleincrement=0.0;//表示权值的增量
doubleweight_temp;output（（double[]）（（Vector<
到实际输岀
//得到期望输出
double[]>）sa.hashmap.get（n））.get（0））;
//得
for（inti=0;i<2;i++）{
vctemp=（Vector）
//对于第i个神经元
vc3.get（i）;
output_error[i]=o_put[i]*（1-o_put[i]）*（temp[i]-
for（intj=0;j<3;j++）{
increment=leaning_rate*output_error[i]*
o_put[i]）;
hidden_output[j];
weight_temp=（（Double）
vctemp.get（j））.doubleValue（）+increment;
vctemp.add（j,weight_temp）;
}
}
returnoutput_error;
}
publicdouble[]adjust_secondlevel_weight（
intn）{//
根据第n个样本来调整隐
层的权值根据7-167-17
inti=0,j=0;
doubleoutput_error[]=newdouble[3];//用于存放隐层每个神经元的输出误
差
doubletemp[]=adjust_outputlevel_weight（n）;//得到输出层每个神经元的输出误差
for（i=0;i<3;i++）{
output_error[i]=hidden_output[i]*（1-hidden_output[i]）*
（（（Double）（（Vector）
vc3.get（0））.get（i））.doubleValue（）*temp[0]+
（（Double）（（Vector）vc3.get
（1））.get（i））.doubleValue（）*temp[1]）;
}
Vectorvctemp;
doubleincrement;
for（i=0;i<3;i++）{
vctemp=（Vector）vc2.get（i）;
for（j=0;j<4;j++）{
increment=leaning_rate*output_error[i]*in_output[j];
vctemp.add（j,（（Double）vctemp.get（j））.doubleValue（）+increment）;
}
}
returnoutput_error;
}
publicvoidadjust_firstlevle_weight（值7-16和7-17
intn）{//根据第n个样本来调整输入层的权
inti=0,j=0;
doubleoutput_error[]=newdouble[4];//用于存放输入层每个神经元的输出误差
doubletemp[]=adjust_secondlevel_weight（n）;//得到隐层每个神经元的输
出误差
for（i=0;i<4;i++）{output_error[i]=
in_output[i]*（1-
in_output[i]）*
（（（Double）（（Vector）
vc2.get（0））.get（i））.doubleValue（）*temp[0]+
（（Double）（（Vector）
vc2.get
（1））.get（i））.doubleValue（）*temp[1]+
（（Double）（（Vector）
}
Vectorvctemp;doubleincrement;doublenum[];
vc2.get
（2））.get（i））.doubleValue（）*temp[2]）;
for（i=0;i<4;i++）{
vctemp=（Vector）vc1.get（i）;
for（j=0；j<3;j++）{
num=（double
[]）（（Vector）sa.hashmap.get（n））.get（0）;
increment=leaning_rate*output_error[i]*num[j];
vctemp.add（j,（（Double）vctemp.get（j））.doubleValue（）+increment）;
}
}
//returnoutput_error;
}
publicvoidpractice（intn）{〃n表示样本数量训练过程
inti=0;
intt=0;〃临时变量，用于select_small（）的返回值，表示第t个样本
doublesum=1;//表示样本集误差总和
ints=0;
doubletemp=0;
while（sum>min_error）{
sum=0;
for（i=0;ioutput（（（Vector）sa.hashmap.get（i））.get（0））;
temp=calculate_ep（o_put,i）;
sum+=temp;
if（s==0）{
ep[i]=temp;
}
adjust_firstlevle_weight（i）;
}
s++;
}
/*for（i=0;i<400;i++）{
System.out.println（ep[i]）;
}*/
}
publicvoidstudy（intn）{//测试
for（inti=0;ioutput（（（Vector）sa.hashmap2.get（i））.get（0））;
ep2[i]=calculate_ep（o_put,i）;
System.out.println（ep2[i]）;
样本和测试程序：
//packageBackPropagation;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Vector;
publicclassSample{
Vectorz;
doublex[],y[];
Map>hashmap;
Map>hashmap2;
Sample（）{
x=newdouble[3];
y=newdouble[2];
z=newVector
（2）;
个训练样本
个测试样本
hashmap=newHashMap>（400）;//400hashmap2=newHashMap>（100）;//100for（inti=0;i<400;i++）{//400个样本
for（intj=0;j<3;j++）{
x[j]=Math.random（）*100;
}
for（intk=0;k<2;k++）{
y[k]=Math.random（）*100;
}
z.add（x）;
z.add（y）;
hashmap.put（i,z）;
}
for（inti=0;i<100;i++）{
for（intj=0;j<3;j++）{
x[j]=Math.random（）;
}
for（intk=0;k<2;k++）{
y[k]=Math.random（）;
}
z.add（x）;
z.add（y）;
hashmap2.put（i,z）;
}
}
}
作图程序：
//packageBackPropagation;
importjava.awt.Color;
importjava.awt.Frame;
importjava.awt.Graphics;
publicclassCurveextendsFrame{BackPropagationbp=newBackPropagation（）;doubletemp[]=bp.ep;
publicvoidpaint（Graphicsg）{this.setBackground（Color.GRAY）;g.setColor（Color.BLACK）;
for（inti=0;i<100;i++）{g.drawLine（i*10,（int）（temp[i]*10000）,（i+1）*10,（int）（temp[i+1]*10000））;//System.out.println（（int）（temp[i]*10000））;
}//g.drawLine（0,325,600,125）;
}
publicstaticvoidmain（String[]args）{
Curvecurve=newCurve（）;curve.setSize（600,600）;curve.setLocation（100,100）;curve.setVisible（true）;
升级会员 