JOONE实现人工智能实例(Java源代码)

1. package com.sweetop.test;
3. import java.io.Serializable;
4. import java.util.Arrays;
5. import java.util.Vector;
7. import org.joone.engine.FullSynapse;
8. import org.joone.engine.LinearLayer;
9. import org.joone.engine.Monitor;
10. import org.joone.engine.NeuralNetEvent;
11. import org.joone.engine.NeuralNetListener;
12. import org.joone.engine.Pattern;
13. import org.joone.engine.SigmoidLayer;
14. import org.joone.engine.learning.TeachingSynapse;
15. import org.joone.io.FileInputSynapse;
16. import org.joone.io.FileOutputSynapse;
17. import org.joone.io.MemoryInputSynapse;
18. import org.joone.io.MemoryOutputSynapse;
19. import org.joone.net.NeuralNet;
21. public class Test implements NeuralNetListener,Serializable {
22.     /**
23.      * 
24.      */
25.     private static final long serialVersionUID = 61750666816215273L;
26.     private NeuralNet nnet = null;
27.     private MemoryInputSynapse inputSynapse, desiredOutputSynapse;
28.     private MemoryOutputSynapse outputSynapse;
30.     // XOR input
31.     private double[][] inputArray = new double[][] { { 1.0, 1.0 },
32.             { 1.0, 2.0 }, { 2.0, 2.0 }, { 2.0, 3.0 }, { 1.0, 3.0 } };
34.     // XOR desired output
35.     private double[][] desiredOutputArray = new double[][] { {  2.0/10 },
36.             { 3.0/10 }, { 4.0/10 }, { 5.0/10 }, {  4.0/10 } };
38.     protected void initNeuralNet() {
39.         // First create the three layers
40.         LinearLayer input = new LinearLayer();
41.         SigmoidLayer hidden = new SigmoidLayer();
42.         SigmoidLayer output = new SigmoidLayer();
44.         input.setLayerName("input");
45.         hidden.setLayerName("hidden");
46.         output.setLayerName("output");
48.         // set the dimensions of the layers
49.         input.setRows(2);
50.         hidden.setRows(3);
51.         output.setRows(1);
53.         // Now create the two Synapses
54.         FullSynapse synapse_IH = new FullSynapse(); /* input -> hidden conn. */
55.         FullSynapse synapse_HO = new FullSynapse(); /* hidden -> output conn. */
57.         // Connect the input layer whit the hidden layer
58.         input.addOutputSynapse(synapse_IH);
59.         hidden.addInputSynapse(synapse_IH);
61.         // Connect the hidden layer whit the output layer
62.         hidden.addOutputSynapse(synapse_HO);
63.         output.addInputSynapse(synapse_HO);
65.         // the input to the neural net
66.         inputSynapse = new MemoryInputSynapse();
67.         input.addInputSynapse(inputSynapse);
69.         // the output of the neural net
70.         outputSynapse = new MemoryOutputSynapse();
72.         output.addOutputSynapse(outputSynapse);
74.         // The Trainer and its desired output
75.         desiredOutputSynapse = new MemoryInputSynapse();
77.         TeachingSynapse trainer = new TeachingSynapse();
79.         trainer.setDesired(desiredOutputSynapse);
80.         nnet = new NeuralNet();
82.         nnet.addLayer(input, NeuralNet.INPUT_LAYER);
83.         nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER);
84.         nnet.addLayer(output, NeuralNet.OUTPUT_LAYER);
85.         nnet.setTeacher(trainer);
86.         output.addOutputSynapse(trainer);
87.         train();
88. //      File
89.     }
91.     public void test(double[][] d){
92.         inputSynapse.setInputArray(d);
93.         inputSynapse.setAdvancedColumnSelector("1,2");
94.         nnet.getMonitor().setTotCicles(1);
95.         nnet.start();
96.         nnet.getMonitor().Go();
97.         for (Object o : outputSynapse.getAllPatterns()) {
98.             Pattern p = (Pattern) o;
99.             System.out.println(10*p.getArray()[0]);
100.         }       
101.     }
102.     public void train() {
103.         // set the inputs
104.         inputSynapse.setInputArray(inputArray);
105.         inputSynapse.setAdvancedColumnSelector("1,2");
106.         // set the desired outputs
107.         desiredOutputSynapse.setInputArray(desiredOutputArray);
108.         desiredOutputSynapse.setAdvancedColumnSelector("1");
110.         // get the monitor object to train or feed forward
111.         Monitor monitor = nnet.getMonitor();
113.         // set the monitor parameters
114.         monitor.setLearningRate(0.8);
115.         monitor.setMomentum(0.3);
116.         monitor.setTrainingPatterns(inputArray.length);
117.         monitor.setTotCicles(100000);
118.         monitor.setLearning(true);
119.         nnet.addNeuralNetListener(this);
120.         nnet.start();
121.         nnet.getMonitor().Go();
122.         for (Object o : outputSynapse.getAllPatterns()) {
123.             Pattern p = (Pattern) o;
124.             System.out.println(10*p.getArray()[0]);
125.         }
126.     }
127.     
128.     public void cicleTerminated(NeuralNetEvent e) {
129.         
130.     }
132.     public void errorChanged(NeuralNetEvent e) {
134.     }
136.     public void netStarted(NeuralNetEvent e) {
137.         // TODO Auto-generated method stub
139.     }
141.     public void netStopped(NeuralNetEvent e) {
142.         // TODO Auto-generated method stub
144.     }
146.     public void netStoppedError(NeuralNetEvent e, String error) {
148.     }
150. }