BP神经网络JAVA实现源码含两套训练测试数据

package bpnn;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Random;

class BPNN implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = -7717308986971656838L;
	// private static int layer = 3; // 三层神经网络
	private static int NodeNum = 10; // 每层的最多节点数
	private static final int ADJUST = 5; // 隐层节点数调节常数
	private static final int MaxTrain = 200000; // 最大训练次数
	private static final double ACCU = 0.015; // 每次迭代允许的误差 iris:0.015
	private double ETA_W = 0.5; // 权值学习效率0.5
	private double ETA_T = 0.5; // 阈值学习效率
	private double accu;

	// 附加动量项
	// private static final double ETA_A = 0.3; // 动量常数0.1
	// private double[][] in_hd_last; // 上一次的权值调整量
	// private double[][] hd_out_last;

	private int in_num; // 输入层节点数
	private int hd_num; // 隐层节点数
	private int out_num; // 输入出节点数

	private ArrayList> alllist = new ArrayList<>（）; // 输入输出数据
	private ArrayList outlist = new ArrayList（）; // 存放分类的字符串

	private double[][] in_hd_weight; // BP网络in-hidden突触权值
	private double[][] hd_out_weight; // BP网络hidden_out突触权值
	private double[] in_hd_th; // BP网络in-hidden阈值
	private double[] hd_out_th; // BP网络hidden-out阈值

	private double[][] out; // 每个神经元的值经S型函数转化后的输出值，输入层就为原值
	private double[][] delta; // delta学习规则中的值

	// 获得网络三层中神经元最多的数量
	public int GetMaxNum（） {
		return Math.max（Math.max（in_num hd_num） out_num）;
	}

	// 设置权值学习率
	public void SetEtaW（） {
		ETA_W = 0.5;
	}

	// 设置阈值学习率
	public void SetEtaT（） {
		ETA_T = 0.5;
	}

	// BPNN训练
	public void Train（int in_number int out_number ArrayList> arraylist ArrayList outlist）
			throws IOException {
		this.alllist = arraylist;
		this.outlist = outlist;
		this.in_num = in_number;
		this.out_num = out_number;

		GetNums（in_num out_num）; // 获取输入层、隐层、输出层的节点数
		// SetEtaW（）; // 设置学习率
		// SetEtaT（）;

		InitNetWork（）; // 初始化网络的权值和阈值

		int datanum = alllist.size（）; // 训练数据的组数
		int createsize = GetMaxNum（）; // 比较创建存储每一层输出数据的数组
		out = new double[3][createsize];

		for （int iter = 0; iter < MaxTrain; iter++） {
			for （int cnd = 0; cnd < datanum; cnd++） {
				// 第一层输入节点赋值

				for （int i = 0; i < in_num; i++） {
					out[0][i] = alllist.get（cnd）.get（i）; // 为输入层节点赋值，其输入与输出相同
				}
				Forward（）; // 前向传播
				Backward（cnd）; // 误差反向传播

			}
			System.out.println（“This is the “ + （iter + 1） + “ th trainning NetWork !“）;
			accu = GetAccu（）;
			System.out.println（“All Samples Accuracy is “ + accu）;
			if （accu < ACCU）
				break;

		}

	}

	// 获取输入层、隐层、输出层的节点数，in_number、out_number分别为输入层节点数和输出层节点数
	public void GetNums（int in_number int out_number） {
		in_num = in_number;
		out_num = out_number;
		hd_num = （int） Math.sqrt（in_num + out_num） + ADJUST;
		if （hd_num > NodeNum）
			hd_num = NodeNum; // 隐层节点数不能大于最大节点数
	}

	// 初始化网络的权值和阈值
	public void InitNetWork（） {
		// 初始化上一次权值量范围为-0.5-0.5之间
		// in_hd_last = new double[in_num][hd_num];
		// hd_out_last = new double[hd_num][out_num];

		in_hd_weight = new