Joone 示例2

package com.pintn.joone;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;
import java.util.Vector;

import org.joone.engine.FullSynapse;
import org.joone.engine.LinearLayer;
import org.joone.engine.Monitor;
import org.joone.engine.NeuralNetEvent;
import org.joone.engine.NeuralNetListener;
import org.joone.engine.Pattern;
import org.joone.engine.SigmoidLayer;
import org.joone.engine.learning.TeachingSynapse;
import org.joone.io.MemoryInputSynapse;
import org.joone.io.MemoryOutputSynapse;
import org.joone.net.NeuralNet;

public class XOR_using_NeuralNet_RPROP implements NeuralNetListener,Serializable {
    private NeuralNet nnet = null; /* 初始化数据网络为空*/
    private MemoryInputSynapse  inputSynapse, desiredOutputSynapse; /*声明MemoryInputSynapse 的两个对象，输入神经元和 期望输出神经元为数组变量 */
    private MemoryOutputSynapse outputSynapse;
   
    // XOR input    双精度型二维数组 inputArray 并初始化  作为神经元的两个输入变量的数组   
    private double[][] inputArray = new double[][] {
        {0.0, 0.0},
        {0.0, 1.0},
        {1.03, 0.0},
        {0.98, 1.0}
    };
   
    // XOR desired output  双精度型二维数组 inputArray 并初始化  作为神经元的期望输出变量的数组  
    private double[][] desiredOutputArray = new double[][] {
        {0.0},
        {1.0},
        {0.103},
        {0.0}
    };
   
   
    public static void main(String args[]) {
XOR_using_NeuralNet_RPROP xor = new XOR_using_NeuralNet_RPROP();
       
       
        xor.initNeuralNet(); 
        xor.train();     
    }
   
     
    protected void initNeuralNet() {       //神经网络的初始化函数
       
        // First create the three layers
     LinearLayer  input = new LinearLayer();     
     SigmoidLayer hidden = new SigmoidLayer();   
     SigmoidLayer output = new SigmoidLayer();
       
        // set the dimensions of the layers
        input.setRows(2);   //   输入层神经元的个数为2   因为 异或（0，1）（1，1）（1，1）（0，0）
        hidden.setRows(3);  //隐含层的神经元个数为 3 这个要根据实际的经验选取
        output.setRows(1);  //输出层的神经元个数为 1   输出异或运算结果
       
        // Now create the two Synapses
        FullSynapse synapse_IH = new FullSynapse();
        FullSynapse synapse_HO = new FullSynapse();
       
        // Connect the input layer whit the hidden layer
        input.addOutputSynapse(synapse_IH); 
        hidden.addInputSynapse(synapse_IH);    
       
        // Connect the hidden layer whit the output layer
        hidden.addOutputSynapse(synapse_HO);
        output.addInputSynapse(synapse_HO);
       
        // the input to the neural net
        inputSynapse = new MemoryInputSynapse();
       
        input.addInputSynapse(inputSynapse);  //将输入神经元的输入作为神经网络 突触的输入变量
       
        // the output of the neural net
        outputSynapse = new MemoryOutputSynapse();
       
        output.addOutputSynapse(outputSynapse);//将输出神经元的输出作为神经网络突触的输入变量
       
        // The Trainer and its desired output
        desiredOutputSynapse = new MemoryInputSynapse();
       
        TeachingSynapse trainer = new TeachingSynapse();
       
        trainer.setDesired(desiredOutputSynapse);  //建立教师层，监视神经网络
       
        // Now we add this structure to a NeuralNet object//添加上面建立的神经网络的结构到神经网络
        nnet = new NeuralNet();
       
        nnet.addLayer(input, NeuralNet.INPUT_LAYER);
        nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER);
        nnet.addLayer(output, NeuralNet.OUTPUT_LAYER);
        nnet.setTeacher(trainer);
        output.addOutputSynapse(trainer);
    }
   
   
    public void train() {
       
        // set the inputs
        inputSynapse.setInputArray(inputArray);   //神经网络的输入数组为inputArray数组
        inputSynapse.setAdvancedColumnSelector("1,2");//选择inputArray数组  前两个变量为输入变量
       
        // set the desired outputs
      desiredOutputSynapse.setInputArray(desiredOutputArray);
        desiredOutputSynapse.setAdvancedColumnSelector("1");//选择outputArray数组前一个变量为输出变量
       
        // get the monitor object to train or feed forward   建立监控连接 和  误差的前向反馈
        Monitor monitor = nnet.getMonitor();  
       
        // set the monitor parameters
        monitor.setLearningRate(0.8); //设定神经网络的学习率，
        monitor.setMomentum(0.3);//设定神经网络的动量 为 0.3 这两个变量与步长有关
        monitor.setTrainingPatterns(inputArray.length);//训练的模式为输入数组的长度
        monitor.setTotCicles(5000);     //设定总训练次数为5000
        // RPROP parameters
//        monitor.getl
//        monitor.getLearner().add(0, "org.joone.engine.RpropLearner");
//        monitor.getLearners().add(0, "org.joone.engine.RpropLearner");
        monitor.setBatchSize(7);//修改
        monitor.setLearningMode(0);
       
        monitor.setLearning(true);//待学习的训练监控 
        nnet.addNeuralNetListener(this);//监听神经网络
        nnet.start();   //数据网路开始训练
        nnet.getMonitor().Go();//神经网络开始监控，并运行
    }
   
   
    public void cicleTerminated(NeuralNetEvent e) {
System.out.println("cicleTerminated...");//训练终结
    }
   
    public void errorChanged(NeuralNetEvent e) {
  // System.out.println("error...");
         Monitor mon = (Monitor)e.getSource();//得到监控层的信息
         System.out.println("Cycle: "+(mon.getTotCicles()-mon.getCurrentCicle())+" RMSE:"+mon.getGlobalError());    //输出  训练的次数和  rmse 均方误差
   }
   
    public void netStarted(NeuralNetEvent e) {
System.out.println("Training...");
    }
   
    public void netStopped(NeuralNetEvent e) {
  System.out.println("Training Stopped...");
 

  System.out.println(5000);
        Monitor mon = (Monitor)e.getSource();
        // Read the last pattern and print it out
        Vector patts = outputSynapse.getAllPatterns();
        Pattern pattern = (Pattern)patts.elementAt(patts.size() - 1);
        System.out.println("Output Pattern = " + pattern.getArray()[0] + " Error: " + mon.getGlobalError());   //输出最后的输出的结果和RMSE值  
        Date Mydate =new Date();  //初始化一个时间对象
        long mystr = System.currentTimeMillis(); //初始化当前的系统时间
        System.out.println(mystr); 
       
        saveNeuralNet("d:"+ mystr +"myxor.snet"); //保存生成当前时间的myxor.snet神经网络
    }
public void saveNeuralNet(String fileName) {
try {
FileOutputStream stream = new FileOutputStream(fileName);
ObjectOutputStream out = new ObjectOutputStream(stream);
out.writeObject(nnet);//写入nnet对象
out.close();
}
catch (Exception excp) {
excp.printStackTrace();
}
}




    private NeuralNet restoreNeuralNet(String fileName) {
        NeuralNet nnet = null;  
        try {
            FileInputStream stream = new FileInputStream(fileName);
            ObjectInput input = new ObjectInputStream(stream);
            nnet = (NeuralNet)input.readObject();
        }
        catch (Exception e) {
            System.out.println( "Exception was thrown. Message is : " + e.getMessage());
        }
        return nnet;
    }
 
   
   
    public void netStoppedError(NeuralNetEvent e, String error) {
    }
   
}