BP算法 Java源代码求大神看看问题出哪了

weixin_41613988 2018-03-30 05:07:41

package BP;
import java.util.*;
public class Displayneuro {

public static void main(String[] args) {
TestNeuro neuro=new TestNeuro(2,2,20);//输入层2个节点，输出层2个节点，隐含层20个节点（一个隐含层）
double[] input=new double[2];
double[] expectedoutput=new double[2];
double [] result=new double[2];
// 训练样本 5000次
for (int n=0;n<4000;n++) {
for (int i=0;i<input.length;i++) {
input[i]=Math.random();
//neuro.initialize();
neuro.train(input, expectedoutput);

}
// System.out.println("请输出："+neuro.predict(input));
}
//根据训练结果来检验样本数据
for (int i=0;i<input.length;i++) {
result=neuro.predict(input);
System.out.println(result[i]);

}

//根据训练结果来预测一条新数据

for (int i=0;i<input.length;i++) {
double[] x=new double[] {Math.random()};// 随机重新取一个随机数作为新的输入，预测输出
result=neuro.predict(x);
System.out.println(result[i]);
}

}

}

package BP;// 构建一个含有一个隐含层，且输入层有2个节点，隐含层20个节点，输出层2个节点的BP神经网络
import java.util.Scanner;
import java.util.Random;

public class TestNeuro {
private int INPUT_DIM=2;
private int HIDDEN_DIM=20;
private int OUTPUT_DIM=2;
private double LEARNING_RATES=0.05;
double []outputvalue;
double[] expectedoutput;
double[][]layer;//神经网络各层节点
double[][] layerr;//神经网络各节点误差
double [][]INPUT_HIDDEN_weights=new double[INPUT_DIM][HIDDEN_DIM];//隐含层输入权重
double [][] OUTPUT_HIDDEN_weights=new double[HIDDEN_DIM][OUTPUT_DIM];//隐含层输出权重
double HIDDEN_thresholds;//隐含层阈值
double OUTPUT_thresholds;//输出层阈值

public TestNeuro(int input_dimenson,int output_dimenson,int hidden_dimenson) {
this.INPUT_DIM=input_dimenson;
this.OUTPUT_DIM=output_dimenson;
this.HIDDEN_DIM=hidden_dimenson;
this.initialize();
}

// 初始化权重
public void initialize() {
for(int i=0;i<INPUT_DIM;i++) {
for(int j=0;j<HIDDEN_DIM;j++) {
INPUT_HIDDEN_weights[j][i]=Math.random() ;//隐含层输入权重取随机数
//System.out.println(INPUT_HIDDEN_weights[j][i]);
}
for(int j=0;j<HIDDEN_DIM;j++) {
for(int l=0;l<OUTPUT_DIM;l++) {
OUTPUT_HIDDEN_weights[l][j]=Math.random();//隐含层输出权重取随机数
//System.out.println(OUTPUT_HIDDEN_weights[l][j]);
}

}

HIDDEN_thresholds=Math.random();//隐含层阈值取值
OUTPUT_thresholds=Math.random();// 输出层阈值取值
}
}

// 逐层向前计算输出
double function(double x) {
return 1/(1+Math.pow(Math.E, -x));

}
public double[] predict (double[] input){

double hiddenvalues[]=new double[HIDDEN_DIM];
for (int i=0;i<HIDDEN_DIM;i++) {
double sum=0;
for (int j=0;j<INPUT_DIM;j++) {
sum+=input[j]*INPUT_HIDDEN_weights[j][i];
}
sum+=HIDDEN_thresholds;
hiddenvalues[i]=function(sum);

}
// double sum2=0;
double outputvalue[]=new double[OUTPUT_DIM];
for(int j=0;j<OUTPUT_DIM;j++) {
double sum2=0;
for(int k=0;k<HIDDEN_DIM;j++) {
sum2+=hiddenvalues[k]*OUTPUT_HIDDEN_weights[j][k];

}
sum2+=OUTPUT_thresholds;
outputvalue[j]=sum2;

}

return outputvalue ;
}

//逐层反向计算误差并修改权重
public void updateWeight(double[]expectedoutput) {
double [] hiddenvalues=new double[HIDDEN_DIM];

double[] outputvalue=new double[OUTPUT_DIM];
double [] factor=new double[OUTPUT_DIM];

for(int k=0;k<OUTPUT_DIM;k++) {
factor[k] =(expectedoutput[k]-outputvalue[k])*outputvalue[k]*(1-outputvalue[k])*LEARNING_RATES;
for(int j=0;j<HIDDEN_DIM;j++) {
double delta1=factor[k]*hiddenvalues[j];

OUTPUT_HIDDEN_weights[k][j]+=delta1;//隐含层到输出层权重调整
OUTPUT_thresholds+=delta1;// 隐含层到输出层阈值调整
}
for(int m=0;m<HIDDEN_DIM;m++) {
double delta=factor[k]*hiddenvalues[m]*(1-hiddenvalues[m])*OUTPUT_HIDDEN_weights[k][m];
for (int n=0;n<INPUT_DIM;n++) {
INPUT_HIDDEN_weights[m][n]+=delta;//输入层到隐含层权重调整
HIDDEN_thresholds+=delta;//输入层到隐含层阈值调整
}
}

}

}

public void train(double[] input,double[]expectedoutput) {
predict(input);
updateWeight(expectedoutput);

}
}

...全文