BP神经网络的Java实现

课程作业要求实现一个BPNN。这次尝试使用Java实现了一个。现共享之。版权属于大家。关于BPNN的原理，就不赘述了。

下面是BPNN的实现代码。类名为BP。

 

package ml;

import java.util.Random;

/**
 * BPNN.
 * 
 * @author RenaQiu
 * 
 */
public class BP {
	/**
	 * input vector.
	 */
	private final double[] input;
	/**
	 * hidden layer.
	 */
	private final double[] hidden;
	/**
	 * output layer.
	 */
	private final double[] output;
	/**
	 * target.
	 */
	private final double[] target;

	/**
	 * delta vector of the hidden layer .
	 */
	private final double[] hidDelta;
	/**
	 * output layer of the output layer.
	 */
	private final double[] optDelta;

	/**
	 * learning rate.
	 */
	private final double eta;
	/**
	 * momentum.
	 */
	private final double momentum;

	/**
	 * weight matrix from input layer to hidden layer.
	 */
	private final double[][] iptHidWeights;
	/**
	 * weight matrix from hidden layer to output layer.
	 */
	private final double[][] hidOptWeights;

	/**
	 * previous weight update.
	 */
	private final double[][] iptHidPrevUptWeights;
	/**
	 * previous weight update.
	 */
	private final double[][] hidOptPrevUptWeights;

	public double optErrSum = 0d;

	public double hidErrSum = 0d;

	private final Random random;

	/**
	 * Constructor.
	 * <p>
	 * <strong>Note:</strong> The capacity of each layer will be the parameter
	 * plus 1. The additional unit is used for smoothness.
	 * </p>
	 * 
	 * @param inputSize
	 * @param hiddenSize
	 * @param outputSize
	 * @param eta
	 * @param momentum
	 * @param epoch
	 */
	public BP(int inputSize, int hiddenSize, int outputSize, double eta,
			double momentum) {

		input = new double[inputSize + 1];
		hidden = new double[hiddenSize + 1];
		output = new double[outputSize + 1];
		target = new double[outputSize + 1];

		hidDelta = new double[hiddenSize + 1];
		optDelta = new double[outputSize + 1];

		iptHidWeights = new double[inputSize + 1][hiddenSize + 1];
		hidOptWeights = new double[hiddenSize + 1][outputSize + 1];

		random = new Random(19881211);
		randomizeWeights(iptHidWeights);
		randomizeWeights(hidOptWeights);

		iptHidPrevUptWeights = new double[inputSize + 1][hiddenSize + 1];
		hidOptPrevUptWeights = new double[hiddenSize + 1][outputSize + 1];

		this.eta = eta;
		this.momentum = momentum;
	}

	private void randomizeWeights(double[][] matrix) {
		for (int i = 0, len = matrix.length; i != len; i++)
			for (int j = 0, len2 = matrix[i].length; j != len2; j++) {
				double real = random.nextDouble();
				matrix[i][j] = random.nextDouble() > 0.5 ? real : -real;
			}
	}

	/**
	 * Constructor with default eta = 0.25 and momentum = 0.3.
	 * 
	 * @param inputSize
	 * @param hiddenSize
	 * @param outputSize
	 * @param epoch
	 */
	public BP(int inputSize, int hiddenSize, int outputSize) {
		this(inputSize, hiddenSize, outputSize, 0.25, 0.9);
	}

	/**
	 * Entry method. The train data should be a one-dim vector.
	 * 
	 * @param trainData
	 * @param target
	 */
	public void train(double[] trainData, double[] target) {
		loadInput(trainData);
		loadTarget(target);
		forward();
		calculateDelta();
		adjustWeight();
	}

	/**
	 * Test the BPNN.
	 * 
	 * @param inData
	 * @return
	 */
	public double[] test(double[] inData) {
		if (inData.length != input.length - 1) {
			throw new IllegalArgumentException("Size Do Not Match.");
		}
		System.arraycopy(inData, 0, input, 1, inData.length);
		forward();
		return getNetworkOutput();
	}

	/**
	 * Return the output layer.
	 * 
	 * @return
	 */
	private double[] getNetworkOutput() {
		int len = output.length;
		double[] temp = new double[len - 1];
		for (int i = 1; i != len; i++)
			temp[i - 1] = output[i];
		return temp;
	}

	/**
	 * Load the target data.
	 * 
	 * @param arg
	 */
	private void loadTarget(double[] arg) {
		if (arg.length != target.length - 1) {
			throw new IllegalArgumentException("Size Do Not Match.");
		}
		System.arraycopy(arg, 0, target, 1, arg.length);
	}

	/**
	 * Load the training data.
	 * 
	 * @param inData
	 */
	private void loadInput(double[] inData) {
		if (inData.length != input.length - 1) {
			throw new IllegalArgumentException("Size Do Not Match.");
		}
		System.arraycopy(inData, 0, input, 1, inData.length);
	}

	/**
	 * Forward.
	 * 
	 * @param layer0
	 * @param layer1
	 * @param weight
	 */
	private void forward(double[] layer0, double[] layer1, double[][] weight) {
		// threshold unit.
		layer0[0] = 1.0;
		for (int j = 1, len = layer1.length; j != len; ++j) {
			double sum = 0;
			for (int i = 0, len2 = layer0.length; i != len2; ++i)
				sum += weight[i][j] * layer0[i];
			layer1[j] = sigmoid(sum);
		}
	}

	/**
	 * Forward.
	 */
	private void forward() {
		forward(input, hidden, iptHidWeights);
		forward(hidden, output, hidOptWeights);
	}

	/**
	 * Calculate output error.
	 */
	private void outputErr() {
		double errSum = 0;
		for (int idx = 1, len = optDelta.length; idx != len; ++idx) {
			double o = output[idx];
			optDelta[idx] = o * (1d - o) * (target[idx] - o);
			errSum += Math.abs(optDelta[idx]);
		}
		optErrSum = errSum;
	}

	/**
	 * Calculate hidden errors.
	 */
	private void hiddenErr() {
		double errSum = 0;
		for (int j = 1, len = hidDelta.length; j != len; ++j) {
			double o = hidden[j];
			double sum = 0;
			for (int k = 1, len2 = optDelta.length; k != len2; ++k)
				sum += hidOptWeights[j][k] * optDelta[k];
			hidDelta[j] = o * (1d - o) * sum;
			errSum += Math.abs(hidDelta[j]);
		}
		hidErrSum = errSum;
	}

	/**
	 * Calculate errors of all layers.
	 */
	private void calculateDelta() {
		outputErr();
		hiddenErr();
	}

	/**
	 * Adjust the weight matrix.
	 * 
	 * @param delta
	 * @param layer
	 * @param weight
	 * @param prevWeight
	 */
	private void adjustWeight(double[] delta, double[] layer,
			double[][] weight, double[][] prevWeight) {

		layer[0] = 1;
		for (int i = 1, len = delta.length; i != len; ++i) {
			for (int j = 0, len2 = layer.length; j != len2; ++j) {
				double newVal = momentum * prevWeight[j][i] + eta * delta[i]
						* layer[j];
				weight[j][i] += newVal;
				prevWeight[j][i] = newVal;
			}
		}
	}

	/**
	 * Adjust all weight matrices.
	 */
	private void adjustWeight() {
		adjustWeight(optDelta, hidden, hidOptWeights, hidOptPrevUptWeights);
		adjustWeight(hidDelta, input, iptHidWeights, iptHidPrevUptWeights);
	}

	/**
	 * Sigmoid.
	 * 
	 * @param val
	 * @return
	 */
	private double sigmoid(double val) {
		return 1d / (1d + Math.exp(-val));
	}
}

 为了验证正确性，我写了一个测试用例，目的是对于任意的整数（int型），BPNN在经过训练之后，能够准确地判断出它是奇数还是偶数，正数还是负数。首先对于训练的样本（是随机生成的数字），将它转化为一个32位的向量，向量的每个分量就是其二进制形式对应的位上的0或1。将目标输出视作一个4维的向量，[1,0,0,0]代表正奇数，[0,1,0,0]代表正偶数，[0,0,1,0]代表负奇数，[0,0,0,1]代表负偶数。

训练样本为1000个，学习200次。

 

package ml;

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

public class Test {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		BP bp = new BP(32, 15, 4);

		Random random = new Random();
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i != 1000; i++) {
			int value = random.nextInt();
			list.add(value);
		}

		for (int i = 0; i != 200; i++) {
			for (int value : list) {
				double[] real = new double[4];
				if (value >= 0)
					if ((value & 1) == 1)
						real[0] = 1;
					else
						real[1] = 1;
				else if ((value & 1) == 1)
					real[2] = 1;
				else
					real[3] = 1;
				double[] binary = new double[32];
				int index = 31;
				do {
					binary[index--] = (value & 1);
					value >>>= 1;
				} while (value != 0);

				bp.train(binary, real);
			}
		}

		System.out.println("训练完毕，下面请输入一个任意数字，神经网络将自动判断它是正数还是复数，奇数还是偶数。");

		while (true) {
			byte[] input = new byte[10];
			System.in.read(input);
			Integer value = Integer.parseInt(new String(input).trim());
			int rawVal = value;
			double[] binary = new double[32];
			int index = 31;
			do {
				binary[index--] = (value & 1);
				value >>>= 1;
			} while (value != 0);

			double[] result = bp.test(binary);

			double max = -Integer.MIN_VALUE;
			int idx = -1;

			for (int i = 0; i != result.length; i++) {
				if (result[i] > max) {
					max = result[i];
					idx = i;
				}
			}

			switch (idx) {
			case 0:
				System.out.format("%d是一个正奇数\n", rawVal);
				break;
			case 1:
				System.out.format("%d是一个正偶数\n", rawVal);
				break;
			case 2:
				System.out.format("%d是一个负奇数\n", rawVal);
				break;
			case 3:
				System.out.format("%d是一个负偶数\n", rawVal);
				break;
			}
		}
	}

}

 运行结果截图如下：

 这个测试的例子非常简单。大家可以根据自己的需要去使用BP这个类。

评论

57 楼 HiccupHiccup 2016-04-21  

请问楼主  误差计算用的什么方法呢？  

56 楼 cnmyh 2015-09-23  

按照动量算法公式Δx(k+1)=ηΔx(k)+α(1-η)∂E(k)/∂x(k)，但是楼主的代码double newVal = momentum * prevWeight[j][i] + eta * delta[i]* layer[j];怎么少了（1-momentum）部分，能否解释下？

55 楼 zhc0822 2015-08-05  

Albert_ygy 写道

楼主你好，看完你的代码，我有两个疑问：1.成员变量momentum没太理解。它起什么作用？2.楼主采用的权值调整是通过每一层的输出误差来调整上一层的权值，而我查的资料是通过最后一层的输出层来逐层往前调整的。这种差异对结果是否有影响呢？求楼主解答，谢谢！

1. momentum 用于平滑weight的change
2. 请仔细看adjustWeight()方法

54 楼 Albert_ygy 2015-08-01  

楼主你好，看完你的代码，我有两个疑问：1.成员变量momentum没太理解。它起什么作用？2.楼主采用的权值调整是通过每一层的输出误差来调整上一层的权值，而我查的资料是通过最后一层的输出层来逐层往前调整的。这种差异对结果是否有影响呢？求楼主解答，谢谢！

53 楼 zhc0822 2015-05-18  

Thare_Lam 写道

Thare_Lam 写道

lz你好,首先非常感谢你的分享.
我认真研究了下你的代码,和书上的算法步骤是一样的,就是少了个阈值.我现在也在用java实现一个bp网络,但我的数据是6维的,一共有8类数据.我想请教下输出层改怎么设定?是8位,哪一位为1就代表哪一类还是3位,用二进制来表示各类?我感觉这两种方法都怪怪的.我自己按照你的代码敲了一遍,然后用自己的数据去算,算出的结果误差非常大(以上两种输出层设置方法都试了),经常是基本上全部都算成同一类了(我也是把输出最大的那个设为1).lz能帮我看看这应该怎么设计吗?

额 我发现改小了momentum和eta后准确率就到80%左右了 不知道这个准确率算不算高呢

多谢留言。momentum, eta, 隐层数目需要自己微调。80%的准确率高不高倒不好说，跟训练次数、训练集大小和测试集大小等有关系。尤其需要注意的是，训练次数并非越多越好，过多epoch会导致过拟合(overfitting)。

52 楼 Thare_Lam 2015-05-11  

Thare_Lam 写道

lz你好,首先非常感谢你的分享.
我认真研究了下你的代码,和书上的算法步骤是一样的,就是少了个阈值.我现在也在用java实现一个bp网络,但我的数据是6维的,一共有8类数据.我想请教下输出层改怎么设定?是8位,哪一位为1就代表哪一类还是3位,用二进制来表示各类?我感觉这两种方法都怪怪的.我自己按照你的代码敲了一遍,然后用自己的数据去算,算出的结果误差非常大(以上两种输出层设置方法都试了),经常是基本上全部都算成同一类了(我也是把输出最大的那个设为1).lz能帮我看看这应该怎么设计吗?

额 我发现改小了momentum和eta后准确率就到80%左右了 不知道这个准确率算不算高呢

51 楼 Thare_Lam 2015-05-11  

lz你好,首先非常感谢你的分享.
我认真研究了下你的代码,和书上的算法步骤是一样的,就是少了个阈值.我现在也在用java实现一个bp网络,但我的数据是6维的,一共有8类数据.我想请教下输出层改怎么设定?是8位,哪一位为1就代表哪一类还是3位,用二进制来表示各类?我感觉这两种方法都怪怪的.我自己按照你的代码敲了一遍,然后用自己的数据去算,算出的结果误差非常大(以上两种输出层设置方法都试了),经常是基本上全部都算成同一类了(我也是把输出最大的那个设为1).lz能帮我看看这应该怎么设计吗?

50 楼 zhc0822 2015-04-27  

qingqingzijin2014 写道

想知道楼主的代码的输出，是不可能是负数吗？训练了900组了，还是不出负数。。

可以输出负数（图里就有例子）

49 楼 qingqingzijin2014 2015-04-07  

想知道楼主的代码的输出，是不可能是负数吗？训练了900组了，还是不出负数。。

48 楼 qingqingzijin2014 2015-04-05  

特地注册了个号来赞楼主

47 楼 zhc0822 2015-03-30  

木叶纷飞 写道

double real = random.nextDouble();
matrix[i][j] = random.nextDouble() > 0.5 ? real : -real;
请问这两行代码中，为什么要将权值这样设定，而不是直接
matrix[i][j] = random.nextDouble()，我运行了一下，这个是错误的，不明白到底这个初始化到底为什么这样子

-1~1

46 楼 木叶纷飞 2015-03-17  

double real = random.nextDouble();
matrix[i][j] = random.nextDouble() > 0.5 ? real : -real;
请问这两行代码中，为什么要将权值这样设定，而不是直接
matrix[i][j] = random.nextDouble()，我运行了一下，这个是错误的，不明白到底这个初始化到底为什么这样子

45 楼 beaticesmile 2014-09-10  

您好，我想问一下，我是想利用BP神经网络实现时序预测，需要有3个数据输入，得出一个预测值的输出，需要修改哪几个地方呢？刚开始学习神经网络，继续使用该算法实现一个预测模型。所以，拜托拜托，帮帮我~楼主

44 楼 不注册 2014-08-07  

非常感谢分享!  

不过对其中有一个小细节不太理解,
即 "让所有数组大小加1", 并且在实际使用过程中给每层都加了一个输出值固定为1的神经元..
注释里提到的是"for smoothness", 以及另一处forward()里面标记了一个"threshold unit"

我个人的理解是这个算是一个常量, 和回归里用到的误差项类似?

请问可以稍微解释一下这个threashold unit的作用吗?
或者有没有什么paper是研究这个的

望不吝解惑
多谢

43 楼 lj745280746 2014-06-22  

你好，我照着使用js重写了一遍，能正常运行了，但还有些不理解。

optDelta[idx] = o * (1d - o) * (target[idx] - o); 

hidDelta[j] = o * (1d - o) * sum;

double newVal = momentum * prevWeight[j][i] + eta * delta[i]  
                        * layer[j];  

为什么要这样算，这三个公式有什么含义？

42 楼 zhc0822 2013-11-28  

766085346 写道

你好，我想问下，已知1到10  10个数字，我想预测第11个，第十二个  这个怎么实现？关于bp算法我是小白，还望楼主赐教

不好意思，我不明白你的问题。能举个例子否？

41 楼 zhc0822 2013-11-28  

公子芒 写道

还有个问题，你的forwar函数，里面都是采用的 layer1[j] = sigmoid(sum); 方法？？
    输入层到隐藏层的传输函数是sigmoid是对的，但是你的隐藏层到输出层的传输函数难道也是sigmoid？

      private void forward() {
        forward(input, hidden, iptHidWeights);
        forward(hidden, output, hidOptWeights);
    }

??

对的，都是sigmoid函数。

40 楼 766085346 2013-11-13  

你好，我想问下，已知1到10  10个数字，我想预测第11个，第十二个  这个怎么实现？关于bp算法我是小白，还望楼主赐教

39 楼 公子芒 2013-05-01  

还有个问题，你的forwar函数，里面都是采用的 layer1[j] = sigmoid(sum); 方法？？
    输入层到隐藏层的传输函数是sigmoid是对的，但是你的隐藏层到输出层的传输函数难道也是sigmoid？

      private void forward() {
        forward(input, hidden, iptHidWeights);
        forward(hidden, output, hidOptWeights);
    }

??

38 楼 公子芒 2013-05-01  

公子芒 写道

仔细看了，也运行测试了。不过感觉总有些地方不对。看你的程序应该是动量BP算法。（MOBP）
private void outputErr() {
........
[b]optDelta[idx] = o * (1d - o) * (target[idx] - o); [/b]
}[size=medium][/size]
如果按照书上的推导，这部分应该是 optDelta[idx] = -2* 1 * (target[idx] - o);（输出层的敏感度，按照线性函数来推的话应该是f(n)其导数为1）
同样的 下一个方法也有些问题：
private void hiddenErr() {
..............
hidDelta[j] = o * (1d - o) * sum;
}
应该写成： hidDelta[j] = o * (1d - o) * sum;（这个后面是否为sum还不确定）。（隐藏层的传输函数是Log-Sigmoid，其导数是f(n)=a(1-a) 。 同时其敏感度受前一层即第二层的敏感度影响，应该是如上所写的）
正好在学习BP神经网络，你的代码十分清爽优雅，学习了~
我也不知道自己说的是否正确，请指正

  


抱歉，第二个方法   private void hiddenErr() {......}是正确的，后面的也是sum。
sum代表了 输出权值和输出敏感度的内积和。