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这个类。

评论

37 楼 公子芒 2013-05-01  

但是，如果我按照刚刚提到的做法来改的话。会出问题，任意数据都会被当做负奇数（我的第一个测试数据是负奇数）

36 楼 公子芒 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神经网络，你的代码十分清爽优雅，学习了~
我也不知道自己说的是否正确，请指正

35 楼 perveen 2013-01-17  

你好，你的程序是不是没有设定误差值？

34 楼 zhc0822 2012-12-14  

chenjunxt 写道

我把BP里面的方法adjustWeight 的下面一行代码注释掉
//prevWeight[j][i] = newVal;

在Test里面测试也没发现错误，所以不知道prevWeight[j][i] = newVal;这行代码有什么作用？

是给你查看收敛情况的.否则如何确定训练的epoch?打印这个变量就可以观察BPNN在训练时的权值修正的情况,从而判定是否收敛.

33 楼 chenjunxt 2012-12-14  

我把BP里面的方法adjustWeight 的下面一行代码注释掉
//prevWeight[j][i] = newVal;

在Test里面测试

//            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; 
//                } 
//            } 
           
           
           
           
           
           
           
           
           
            Random r = new Random();
            for(int i = 0;i<10000;i++)
            {
            int value = r.nextInt();
            if(r.nextInt()%2==0)
            {
            value = -value;
            }
            int startvalue = 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 j = 0; j != result.length; j++) { 
                  if (result[j] > max) { 
                      max = result[j]; 
                      idx = j; 
                  } 
              }
              if(startvalue>0)
              {
              if(startvalue%2==0)
              {
              if(idx!=1)
              System.err.println("error:"+startvalue);
              }
              else
              {
              if(idx!=0)
              System.err.println("error:"+startvalue);
              }
              }
              else{
              if(startvalue%2==0)
              {
              if(idx!=3)
              System.err.println("error:"+startvalue);
              }
              else
              {
              if(idx!=2)
              System.err.println("error:"+startvalue);
              }
              }
            }

也没发现错误，所以不知道prevWeight[j][i] = newVal;这行代码有什么作用？

32 楼 zhc0822 2012-12-12  

perveen 写道

zhc0822 写道

perveen 写道

可不可以告诉我，你的神经网络代码是怎么样实现输出的，谢谢

test方法输出.

我要是想输入一些样本，输出一些样本，应该怎么改

测试程序第15行,创建一个BPNN,设定各层的神经元数目.
测试程序第43行,通过train方法训练即可,输入向量和输出向量由自己指定,只需要满足创建的神经元的显层(即输入层)和输出层的规模即可,具体可看我26楼的回复.

31 楼 perveen 2012-12-11  

zhc0822 写道

perveen 写道

可不可以告诉我，你的神经网络代码是怎么样实现输出的，谢谢

test方法输出.

我要是想输入一些样本，输出一些样本，应该怎么改

30 楼 zhc0822 2012-12-09  

perveen 写道

可不可以告诉我，你的神经网络代码是怎么样实现输出的，谢谢

test方法输出.

29 楼 perveen 2012-12-09  

可不可以告诉我，你的神经网络代码是怎么样实现输出的，谢谢

28 楼 perveen 2012-12-07  

perveen 写道

你好，请问你的程序，哪段是计算隐含层输出和输出层输出呢？谢谢

知道在哪里了，谢谢

27 楼 perveen 2012-12-07  

你好，请问你的程序，哪段是计算隐含层输出和输出层输出呢？谢谢

26 楼 zhc0822 2012-11-29  

perveen 写道

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 : -    } 
请问我能这段代码是什么意思，还有，如果我想输入指定的22个样本，而不是随机输入1000个样本，请问测试代码哪边需要改动，非常感谢，麻烦了~

这段代码是用来初始化连接权值的。
BP的train方法接受两个参数，第一个参数是输入向量，第二个参数是输出向量。调用这个方法可以完成一次训练。至于学习的epoch，由自己决定。
建议你先好好看看BP，理解BP。

25 楼 perveen 2012-11-28  

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 : -    } 
请问我能这段代码是什么意思，还有，如果我想输入指定的22个样本，而不是随机输入1000个样本，请问测试代码哪边需要改动，非常感谢，麻烦了~

24 楼 zhc0822 2012-11-24  

perveen 写道

zhc0822 写道

perveen 写道

你好，我想问一下，输入量是32位向量，输出又是4位向量，是怎样转化的呢

其实就是一个降维的过程.以3层反向传播神经网络(3层以上的很少使用,收敛太慢,且易陷入局部极小点)为例,显层(即输入层)/隐层/输出层通常是每层比上一层的神经元数目要少一些,通过连接的权值来达到一个降维的效果.

能不能具体一点呢，比如哪段程序是降维的过程，还有，我突然发现，输入的是32位，不是32维，输出的却是4维

整个BP就是一个降维的过程。我已经说过了，是通过层之间的连接权值来达到降维的效果。以前是32位，现在用4位就能表示我们需要的所有信息，这不就是降维吗？

23 楼 perveen 2012-11-24  

你好，能不能回答一下我之前提的问题，谢谢

22 楼 perveen 2012-11-23  

zhc0822 写道

perveen 写道

你好，我想问一下，输入量是32位向量，输出又是4位向量，是怎样转化的呢

其实就是一个降维的过程.以3层反向传播神经网络(3层以上的很少使用,收敛太慢,且易陷入局部极小点)为例,显层(即输入层)/隐层/输出层通常是每层比上一层的神经元数目要少一些,通过连接的权值来达到一个降维的效果.

能不能具体一点呢，比如哪段程序是降维的过程，还有，我突然发现，输入的是32位，不是32维，输出的却是4维

21 楼 zhc0822 2012-11-23  

perveen 写道

你好，我想问一下，输入量是32位向量，输出又是4位向量，是怎样转化的呢

其实就是一个降维的过程.以3层反向传播神经网络(3层以上的很少使用,收敛太慢,且易陷入局部极小点)为例,显层(即输入层)/隐层/输出层通常是每层比上一层的神经元数目要少一些,通过连接的权值来达到一个降维的效果.

20 楼 perveen 2012-11-22  

你好，我想问一下，输入量是32位向量，输出又是4位向量，是怎样转化的呢

19 楼 zhc0822 2012-11-01  

fantaosong 写道

eta = 0.25 and momentum = 0.3,他俩分别表示的是神经元的阈值和学习率吗？

不是有注释吗亲

18 楼 fantaosong 2012-10-31  

eta = 0.25 and momentum = 0.3,他俩分别表示的是神经元的阈值和学习率吗？