bp神经网络的java实现

这两天开始研究BPNN。先阅读的这篇文章：http://www.codeproject.com/Articles/16508/AI-Neural-Network-for-beginners-Part-2-of-3;然后我把这篇文章里的代码按照面向对象的方式重写了一遍。在测试过程中发现一个比较奇怪的问题，两种实现的过程数据是一样的，但最后的计算结果却不一样，这个困扰我好几天了，我把代码贴出来，大家一起研究研究。
第一个类，神经元
public class Neuron {
    static int counter = 0;
    final public int id;  // auto increment, starts at 0
    NeuronConnection biasConnection;
    final double bias = -1;
    double output;
    double deltaOutput = 0;     
    List<NeuronConnection> Inconnections = new ArrayList<NeuronConnection>();
    Map<Integer, NeuronConnection> connMap = new HashMap<Integer, NeuronConnection>();
     
    public Neuron(){        
        id = counter;
        counter++;
    }
    /**
     * Compute Sj = Wij*Aij + w0j*bias
     */
    public void calculateOutput(){
        double s = 0;
        for(NeuronConnection con : Inconnections){
            Neuron leftNeuron = con.getFromNeuron();
            double weight = con.getWeight();
            double a = leftNeuron.getOutput(); //output from previous layer
             
            s = s + (weight*a);
        }
        s = s + (biasConnection.getWeight()*bias);     
        output = g(s);
    }
      
    double g(double x) {
        return sigmoid(x);
    }
 
    double sigmoid(double x) {
        return 1.0 / (1.0 +  (Math.exp(-x)));
    }
     
    public void addInConnectionsS(List<Neuron> inNeurons){
        for(Neuron n: inNeurons){
            NeuronConnection con = new NeuronConnection(n,this);
            Inconnections.add(con);
            connMap.put(n.id, con);
        }
    }
     
    public NeuronConnection getNeuronConn(int id){
        return connMap.get(id);
    }
 
    public void addInConnection(NeuronConnection con){
        Inconnections.add(con);
    }
    public void addBiasConnection(Neuron n){
        NeuronConnection con = new NeuronConnection(n,this);
        biasConnection = con;
        Inconnections.add(con);
        connMap.put(n.id, con);
    }
    public List<NeuronConnection> getAllInConnections(){
        return Inconnections;
    }
     
    public double getBias() {
        return bias;
    }
    public double getOutput() {
        return output;
    }
    public void setOutput(double o){
        output = o;
    }
}


第二个类，神经元之间的连接类
public class NeuronConnection {
    double weight = 0;
    double deltaWeight = 0;
    double prevDeltaWeight = 0; // for momentum
    
    
    final Neuron leftNeuron;
    final Neuron rightNeuron;
    static int counter = 0;
    final public int id; // auto increment, starts at 0
 
    public NeuronConnection(Neuron fromN, Neuron toN) {
        leftNeuron = fromN;
        rightNeuron = toN;
        id = counter;
        counter++;
    }
    
    public double getWeight() {
        return weight;
    }
 
    public void setWeight(double w) {
        weight = w;
    }
 
    public void setDeltaWeight(double w) {
        prevDeltaWeight = deltaWeight;
        deltaWeight = w;
    }
 
    public double getPrevDeltaWeight() {
        return prevDeltaWeight;
    }
 
    public Neuron getFromNeuron() {
        return leftNeuron;
    }
 
    public Neuron getToNeuron() {
        return rightNeuron;
    }
}


第三个类，神经网络
public class BPNN {

    private int[] layers;
    private Neuron bias = new Neuron();
    private double learningRate = 10f;
    private double momentum = 0.7f;
    private List<List<Neuron>> layerList = new ArrayList<List<Neuron>>();
    private Random random = new Random();
    
    public BPNN(int[] layers){
        this.layers = layers;
        init();
    }
    
    public BPNN(int[] layers, double learningRate, double momentum){
        this.layers = layers;
        this.learningRate = learningRate;
        this.momentum = momentum;
        init();
    }
    
    public String toString(){
        int i;
        List<Neuron> list0 = layerList.get(0);
        List<Neuron> list1 = layerList.get(layerList.size() - 1);
        for(i = 0; i < list0.size(); i++){
            System.out.print(list0.get(i).getOutput() + " ");
        }
        for(i = 0; i < list1.size(); i++){
            System.out.println(list1.get(i).getOutput() + " " + list1.get(i).deltaOutput);
        }
        return null;
    }
    
    private void init(){
        int i;
        /*初始化神经网络结构*/
        List<Neuron> list0 = new ArrayList<Neuron>();
        for(i = 0; i < layers[0]; i++){
            Neuron neuron = new Neuron();
            list0.add(neuron);
        }
        layerList.add(list0);
        for(int j = 1; j < layers.length; j++){
            List<Neuron> list = new ArrayList<Neuron>();
            for(i = 0; i < layers[j]; i++){
                Neuron neuron = new Neuron();
                neuron.addInConnectionsS(layerList.get(j - 1));
                neuron.addBiasConnection(bias);
                list.add(neuron);
            }
            layerList.add(list);
        }
        
        /*初始化权重*/
        for(List<Neuron> list : layerList){
            for(Neuron neuron : list){
                for(NeuronConnection conn : neuron.getAllInConnections()){
                    conn.setWeight(2 * random.nextDouble() - 1);
                }
            }
        }
        System.out.println();
    }
    
    /*接收输入参数*/
    public void setInput(double[] inputs){
        List<Neuron> list = layerList.get(0);
        if(list.size() != inputs.length){
            System.err.println("入参数量不对");
        }
        
        for(int i = 0; i < inputs.length; i++){
            list.get(i).setOutput(inputs[i]);
        }
    }
    
    /*前向计算输出,不计算输入层的输出*/
    public void forward(){
        int size = layerList.size();
        for(int i = 1; i < size; i++){
            List<Neuron> list = layerList.get(i);
            for(int j = 0; j < list.size(); j++){
                Neuron n = list.get(j);
                n.calculateOutput();
            }
        }
    }
    
    /*获取计算结果*/
    public double[] getOutput(){
        double[] ret = new double[layers[layers.length - 1]];
        List<Neuron> list = layerList.get(layerList.size() - 1);
        for(int i = 0; i < ret.length; i++){
            ret[i] = list.get(i).getOutput();
        }
        return ret;
    }
    
    /*根据误差反馈修正权重*/
    public void updateWeights(double[] target){
        double e = 1;
        if(target.length != layers[layers.length - 1]){
            System.err.println("期望输出数量错误");
        }
        int size = layerList.size();
        List<Neuron> outputLayer = layerList.get(size - 1);
        int i;
        double delta_output = 0;
        for(i = 0; i < outputLayer.size(); i++){
            Neuron n = outputLayer.get(i);
            double output = n.getOutput();
            e += target[i] - output;
            delta_output = output * (1 - output) * (target[i] - output);
            for(NeuronConnection conn : n.getAllInConnections()){
                double leftNoutput = conn.leftNeuron.getOutput();
                double delta_weight = this.learningRate * delta_output * leftNoutput;
                conn.setDeltaWeight(delta_weight);
                //this.momentum * conn.getPrevDeltaWeight()添加动量影响
                conn.setWeight(conn.getWeight() + delta_weight + this.momentum * conn.getPrevDeltaWeight());
            }
            n.deltaOutput = delta_output;
        }
        
        e = Math.abs(e - 1)/outputLayer.size();
        //TODO反馈修正
        for(i = size - 2; i == 1; i--){
            List<Neuron> hiddenLayer = layerList.get(i);
            List<Neuron> rightLayer = layerList.get(i + 1);
            int j;
            for (j = 0; j < hiddenLayer.size(); j++) {
                Neuron n = hiddenLayer.get(j);
                double output = n.getOutput();
                double error = 0;
                for(int h = 0; h < rightLayer.size(); h++){
                    Neuron rightN = rightLayer.get(h);
                    NeuronConnection conn = rightN.getNeuronConn(n.id);
                    error += rightN.deltaOutput * conn.getWeight();
                }
                n.deltaOutput = output * (1 - output) * error;
                for(int m = 0; m < n.getAllInConnections().size(); m++){
                    NeuronConnection conn = n.getAllInConnections().get(m);
                    double leftNOutput = conn.leftNeuron.getOutput();
                    double delta_weight = this.learningRate * n.deltaOutput * leftNOutput;
                    conn.setDeltaWeight(delta_weight);
                    conn.setWeight(conn.getWeight() + delta_weight + this.momentum * conn.getPrevDeltaWeight());
                }
            }
        }
    }
    
    /*对外训练接口*/
    public void train(double[] inputs, double[] output){
        setInput(inputs);
        forward();
        updateWeights(output);
    }
    
    /*获取计算结果*/
    public double[] result(double[] inputs){
        setInput(inputs);
        forward();
        return getOutput();
    }
    
    /*获取权值矩阵*/
    public List<NeuronConnection> getWeights(){
        List<NeuronConnection> ret = new ArrayList<NeuronConnection>();
        for(List<Neuron> list : layerList){
            for(Neuron neuron : list){
                for(NeuronConnection conn : neuron.getAllInConnections()){
                    ret.add(conn);
                }
            }
        }
        return ret;
    }
    
    public static void main(String[] args){
        int train = 100;
        BPNN n = new BPNN(new int[]{2,2,1});
        while(train-- > 0){
            n.train( new double[]{0,0}, new double[]{0});
            n.toString();
            n.train( new double[]{1,0}, new double[]{1});
            n.toString();
            n.train( new double[]{0,1}, new double[]{1});
            n.toString();
            n.train( new double[]{1,1}, new double[]{0});
            n.toString();
            System.out.println("****************************************");
        }
        for(double d : n.result( new double[]{0,0})){
            System.out.println(d);
        }
        for(double d : n.result( new double[]{1,0})){
            System.out.println(d);
        }
        for(double d : n.result( new double[]{0,1})){
            System.out.println(d);
        }
        for(double d : n.result( new double[]{1,1})){
            System.out.println(d);
        }
    }
}


请大家告诉我到底是哪个地方出现了问题，谢谢您指导。