LSTM java 实现

时间：2024-06-09 18:07:38

由于实验室事情缘故，需要将Python写的神经网络转成Java版本的，但是python中的numpy等啥包也不知道在Java里面对应的是什么工具，所以索性直接寻找一个现成可用的Java神经网络框架，于是就找到了JOONE，JOONE是一个神经网络的开源框架，使用的是BP算法进行迭代计算参数，使用起来比较方便也比较实用，下面介绍一下JOONE的一些使用方法。

JOONE需要使用一些外部的依赖包，这在官方网站上有，也可以在这里下载。将所需的包引入工程之后，就可以进行编码实现了。

首先看下完整的程序，这个是上面那个超链接给出的程序，应该是官方给出的一个示例吧，因为好多文章都用这个，这其实是神经网络训练一个异或计算器：

  1. import org.joone.engine.*;
  2. import org.joone.engine.learning.*;
  3. import org.joone.io.*;
  4. import org.joone.net.*;
  5. /*
  6. *
  7. * JOONE实现
  8. *
  9. * */
  10. public class XOR_using_NeuralNet implements NeuralNetListener
  11. {
  12. private NeuralNet nnet = null;
  13. private MemoryInputSynapse inputSynapse, desiredOutputSynapse;
  14. LinearLayer input;
  15. SigmoidLayer hidden, output;
  16. boolean singleThreadMode = true;
  17. // XOR input
  18. private double[][] inputArray = new double[][]
  19. {
  20. { 0.0, 0.0 },
  21. { 0.0, 1.0 },
  22. { 1.0, 0.0 },
  23. { 1.0, 1.0 } };
  24. // XOR desired output
  25. private double[][] desiredOutputArray = new double[][]
  26. {
  27. { 0.0 },
  28. { 1.0 },
  29. { 1.0 },
  30. { 0.0 } };
  31. /**
  32. * @param args
  33. *            the command line arguments
  34. */
  35. public static void main(String args[])
  36. {
  37. XOR_using_NeuralNet xor = new XOR_using_NeuralNet();
  38. xor.initNeuralNet();
  39. xor.train();
  40. xor.interrogate();
  41. }
  42. /**
  43. * Method declaration
  44. */
  45. public void train()
  46. {
  47. // set the inputs
  48. inputSynapse.setInputArray(inputArray);
  49. inputSynapse.setAdvancedColumnSelector(" 1,2 ");
  50. // set the desired outputs
  51. desiredOutputSynapse.setInputArray(desiredOutputArray);
  52. desiredOutputSynapse.setAdvancedColumnSelector(" 1 ");
  53. // get the monitor object to train or feed forward
  54. Monitor monitor = nnet.getMonitor();
  55. // set the monitor parameters
  56. monitor.setLearningRate(0.8);
  57. monitor.setMomentum(0.3);
  58. monitor.setTrainingPatterns(inputArray.length);
  59. monitor.setTotCicles(5000);
  60. monitor.setLearning(true);
  61. long initms = System.currentTimeMillis();
  62. // Run the network in single-thread, synchronized mode
  63. nnet.getMonitor().setSingleThreadMode(singleThreadMode);
  64. nnet.go(true);
  65. System.out.println(" Total time=  "
  66. + (System.currentTimeMillis() - initms) + "  ms ");
  67. }
  68. private void interrogate()
  69. {
  70. double[][] inputArray = new double[][]
  71. {
  72. { 1.0, 1.0 } };
  73. // set the inputs
  74. inputSynapse.setInputArray(inputArray);
  75. inputSynapse.setAdvancedColumnSelector(" 1,2 ");
  76. Monitor monitor = nnet.getMonitor();
  77. monitor.setTrainingPatterns(4);
  78. monitor.setTotCicles(1);
  79. monitor.setLearning(false);
  80. MemoryOutputSynapse memOut = new MemoryOutputSynapse();
  81. // set the output synapse to write the output of the net
  82. if (nnet != null)
  83. {
  84. nnet.addOutputSynapse(memOut);
  85. System.out.println(nnet.check());
  86. nnet.getMonitor().setSingleThreadMode(singleThreadMode);
  87. nnet.go();
  88. for (int i = 0; i < 4; i++)
  89. {
  90. double[] pattern = memOut.getNextPattern();
  91. System.out.println(" Output pattern # " + (i + 1) + " = "
  92. + pattern[0]);
  93. }
  94. System.out.println(" Interrogating Finished ");
  95. }
  96. }
  97. /**
  98. * Method declaration
  99. */
  100. protected void initNeuralNet()
  101. {
  102. // First create the three layers
  103. input = new LinearLayer();
  104. hidden = new SigmoidLayer();
  105. output = new SigmoidLayer();
  106. // set the dimensions of the layers
  107. input.setRows(2);
  108. hidden.setRows(3);
  109. output.setRows(1);
  110. input.setLayerName(" L.input ");
  111. hidden.setLayerName(" L.hidden ");
  112. output.setLayerName(" L.output ");
  113. // Now create the two Synapses
  114. FullSynapse synapse_IH = new FullSynapse(); /* input -> hidden conn. */
  115. FullSynapse synapse_HO = new FullSynapse(); /* hidden -> output conn. */
  116. // Connect the input layer whit the hidden layer
  117. input.addOutputSynapse(synapse_IH);
  118. hidden.addInputSynapse(synapse_IH);
  119. // Connect the hidden layer whit the output layer
  120. hidden.addOutputSynapse(synapse_HO);
  121. output.addInputSynapse(synapse_HO);
  122. // the input to the neural net
  123. inputSynapse = new MemoryInputSynapse();
  124. input.addInputSynapse(inputSynapse);
  125. // The Trainer and its desired output
  126. desiredOutputSynapse = new MemoryInputSynapse();
  127. TeachingSynapse trainer = new TeachingSynapse();
  128. trainer.setDesired(desiredOutputSynapse);
  129. // Now we add this structure to a NeuralNet object
  130. nnet = new NeuralNet();
  131. nnet.addLayer(input, NeuralNet.INPUT_LAYER);
  132. nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER);
  133. nnet.addLayer(output, NeuralNet.OUTPUT_LAYER);
  134. nnet.setTeacher(trainer);
  135. output.addOutputSynapse(trainer);
  136. nnet.addNeuralNetListener(this);
  137. }
  138. public void cicleTerminated(NeuralNetEvent e)
  139. {
  140. }
  141. public void errorChanged(NeuralNetEvent e)
  142. {
  143. Monitor mon = (Monitor) e.getSource();
  144. if (mon.getCurrentCicle() % 100 == 0)
  145. System.out.println(" Epoch:  "
  146. + (mon.getTotCicles() - mon.getCurrentCicle()) + "  RMSE: "
  147. + mon.getGlobalError());
  148. }
  149. public void netStarted(NeuralNetEvent e)
  150. {
  151. Monitor mon = (Monitor) e.getSource();
  152. System.out.print(" Network started for  ");
  153. if (mon.isLearning())
  154. System.out.println(" training. ");
  155. else
  156. System.out.println(" interrogation. ");
  157. }
  158. public void netStopped(NeuralNetEvent e)
  159. {
  160. Monitor mon = (Monitor) e.getSource();
  161. System.out.println(" Network stopped. Last RMSE= "
  162. + mon.getGlobalError());
  163. }
  164. public void netStoppedError(NeuralNetEvent e, String error)
  165. {
  166. System.out.println(" Network stopped due the following error:  "
  167. + error);
  168. }
  169. }

现在我会逐步解释上面的程序。

【1】 从main方法开始说起，首先第一步新建一个对象：

  1. XOR_using_NeuralNet xor = new XOR_using_NeuralNet();

【2】然后初始化神经网络：

  1. xor.initNeuralNet();

初始化神经网络的方法中：

  1. // First create the three layers
  2. input = new LinearLayer();
  3. hidden = new SigmoidLayer();
  4. output = new SigmoidLayer();
  5. // set the dimensions of the layers
  6. input.setRows(2);
  7. hidden.setRows(3);
  8. output.setRows(1);
  9. input.setLayerName(" L.input ");
  10. hidden.setLayerName(" L.hidden ");
  11. output.setLayerName(" L.output ");

上面代码解释：

input=new LinearLayer()是新建一个输入层，因为神经网络的输入层并没有训练参数，所以使用的是线性层；

hidden = new SigmoidLayer();这里是新建一个隐含层，使用sigmoid函数作为激励函数，当然你也可以选择其他的激励函数，如softmax激励函数

output则是新建一个输出层

之后的三行代码是建立输入层、隐含层、输出层的神经元个数，这里表示输入层为2个神经元，隐含层是3个神经元，输出层是1个神经元

最后的三行代码是给每个输出层取一个名字。

  1. // Now create the two Synapses
  2. FullSynapse synapse_IH = new FullSynapse(); /* input -> hidden conn. */
  3. FullSynapse synapse_HO = new FullSynapse(); /* hidden -> output conn. */
  4. // Connect the input layer whit the hidden layer
  5. input.addOutputSynapse(synapse_IH);
  6. hidden.addInputSynapse(synapse_IH);
  7. // Connect the hidden layer whit the output layer
  8. hidden.addOutputSynapse(synapse_HO);
  9. output.addInputSynapse(synapse_HO);

上面代码解释：

上面代码的主要作用是将三个层连接起来，synapse_IH用来连接输入层和隐含层，synapse_HO用来连接隐含层和输出层

  1. // the input to the neural net
  2. inputSynapse = new MemoryInputSynapse();
  3. input.addInputSynapse(inputSynapse);
  4. // The Trainer and its desired output
  5. desiredOutputSynapse = new MemoryInputSynapse();
  6. TeachingSynapse trainer = new TeachingSynapse();
  7. trainer.setDesired(desiredOutputSynapse);

上面代码解释：

上面的代码是在训练的时候指定输入层的数据和目的输出的数据，

inputSynapse = new MemoryInputSynapse();这里指的是使用了从内存中输入数据的方法，指的是输入层输入数据，当然还有从文件输入的方法，这点在文章后面再谈。同理，desiredOutputSynapse = new MemoryInputSynapse();也是从内存中输入数据，指的是从输入层应该输出的数据

  1. // Now we add this structure to a NeuralNet object
  2. nnet = new NeuralNet();
  3. nnet.addLayer(input, NeuralNet.INPUT_LAYER);
  4. nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER);
  5. nnet.addLayer(output, NeuralNet.OUTPUT_LAYER);
  6. nnet.setTeacher(trainer);
  7. output.addOutputSynapse(trainer);
  8. nnet.addNeuralNetListener(this);

上面代码解释：

这段代码指的是将之前初始化的构件连接成一个神经网络，NeuralNet是JOONE提供的类，主要是连接各个神经层，最后一个nnet.addNeuralNetListener(this);这个作用是对神经网络的训练过程进行监听，因为这个类实现了NeuralNetListener这个接口，这个接口有一些方法，可以实现观察神经网络训练过程，有助于参数调整。

【3】然后我们来看一下train这个方法：

  1. inputSynapse.setInputArray(inputArray);
  2. inputSynapse.setAdvancedColumnSelector(" 1,2 ");
  3. // set the desired outputs
  4. desiredOutputSynapse.setInputArray(desiredOutputArray);
  5. desiredOutputSynapse.setAdvancedColumnSelector(" 1 ");

上面代码解释：

inputSynapse.setInputArray(inputArray);这个方法是初始化输入层数据，也就是指定输入层数据的内容，inputArray是程序中给定的二维数组，这也就是为什么之前初始化神经网络的时候使用的是MemoryInputSynapse，表示从内存中读取数据

inputSynapse.setAdvancedColumnSelector(" 1,2 ");这个表示的是输入层数据使用的是inputArray的前两列数据。

desiredOutputSynapse这个也同理

  1. Monitor monitor = nnet.getMonitor();
  2. // set the monitor parameters
  3. monitor.setLearningRate(0.8);
  4. monitor.setMomentum(0.3);
  5. monitor.setTrainingPatterns(inputArray.length);
  6. monitor.setTotCicles(5000);
  7. <span style="line-height: 1.5;">monitor.setLearning(true);

上面代码解释：

这个monitor类也是JOONE框架提供的，主要是用来调节神经网络的参数，monitor.setLearningRate(0.8);是用来设置神经网络训练的步长参数，步长越大，神经网络梯度下降的速度越快，monitor.setTrainingPatterns(inputArray.length);这个是设置神经网络的输入层的训练数据大小size，这里使用的是数组的长度；monitor.setTotCicles(5000);这个指的是设置迭代数目；monitor.setLearning(true);这个true表示是在训练过程。

  1. nnet.getMonitor().setSingleThreadMode(singleThreadMode);
  2. nnet.go(true);

上面代码解释：

nnet.getMonitor().setSingleThreadMode(singleThreadMode);这个指的是是不是使用多线程，但是我不太清楚这里的多线程指的是什么意思

nnet.go(true)表示的是开始训练。

【4】最后来看一下interrogate方法

  1. double[][] inputArray = new double[][]
  2. {
  3. { 1.0, 1.0 } };
  4. // set the inputs
  5. inputSynapse.setInputArray(inputArray);
  6. inputSynapse.setAdvancedColumnSelector(" 1,2 ");
  7. Monitor monitor = nnet.getMonitor();
  8. monitor.setTrainingPatterns(4);
  9. monitor.setTotCicles(1);
  10. monitor.setLearning(false);
  11. MemoryOutputSynapse memOut = new MemoryOutputSynapse();
  12. // set the output synapse to write the output of the net
  13. if (nnet != null)
  14. {
  15. nnet.addOutputSynapse(memOut);
  16. System.out.println(nnet.check());
  17. nnet.getMonitor().setSingleThreadMode(singleThreadMode);
  18. nnet.go();
  19. for (int i = 0; i < 4; i++)
  20. {
  21. double[] pattern = memOut.getNextPattern();
  22. System.out.println(" Output pattern # " + (i + 1) + " = "
  23. + pattern[0]);
  24. }
  25. System.out.println(" Interrogating Finished ");
  26. }

这个方法相当于测试方法，这里的inputArray是测试数据， 注意这里需要设置monitor.setLearning(false);，因为这不是训练过程，并不需要学习，monitor.setTrainingPatterns(4);这个是指测试的数量，4表示有4个测试数据（虽然这里只有一个）。这里还给nnet添加了一个输出层数据对象，这个对象mmOut是初始测试结果，注意到之前我们初始化神经网络的时候并没有给输出层指定数据对象，因为那个时候我们在训练，而且指定了trainer作为目的输出。

接下来就是输出结果数据了，pattern的个数和输出层的神经元个数一样大，这里输出层神经元的个数是1，所以pattern大小为1.

【5】我们看一下测试结果：

  1. Output pattern # 1 = 0.018303527517809233

表示输出结果为0.01，根据sigmoid函数特性，我们得到的输出是0，和预期结果一致。如果输出层神经元个数大于1，那么输出值将会有多个，因为输出层结果是0|1离散值，所以我们取输出最大的那个神经元的输出值取为1，其他为0

【6】最后我们来看一下神经网络训练过程中的一些监听函数：

cicleTerminated：每个循环结束后输出的信息

errorChanged：神经网络错误率变化时候输出的信息

netStarted：神经网络开始运行的时候输出的信息

netStopped：神经网络停止的时候输出的信息

【7】好了，JOONE基本上内容就是这些。还有一些额外东西需要说明：

1，从文件中读取数据构建神经网络

2.如何保存训练好的神经网络到文件夹中，只要测试的时候直接load到内存中就行，而不用每次都需要训练。

【8】先看第一个问题：

从文件中读取数据：

文件的格式：

0;0;0

1;0;1

1;1;0

0;1;1

中间使用分号隔开，使用方法如下，也就是把上文的MemoryInputSynapse换成FileInputSynapse即可。

  1. fileInputSynapse = new FileInputSynapse();
  2. input.addInputSynapse(fileInputSynapse);
  3. fileDisireOutputSynapse = new FileInputSynapse();
  4. TeachingSynapse trainer = new TeachingSynapse();
  5. trainer.setDesired(fileDisireOutputSynapse);

我们看下文件是如何输出数据的：

  1. private File inputFile = new File(Constants.TRAIN_WORD_VEC_PATH);
  2. fileInputSynapse.setInputFile(inputFile);
  3. fileInputSynapse.setFirstCol(2);//使用文件的第2列到第3列作为输出层输入
  4. fileInputSynapse.setLastCol(3);
  1. fileDisireOutputSynapse.setInputFile(inputFile);
  2. fileDisireOutputSynapse.setFirstCol(1);//使用文件的第1列作为输出数据
  3. fileDisireOutputSynapse.setLastCol(1);

其余的代码和上文的是一样的。

【9】然后看第二个问题：

如何保存神经网络

其实很简单，直接序列化nnet对象就行了，然后读取该对象就是java的反序列化，这个就不多做介绍了，比较简单。但是需要说明的是，保存神经网络的时机一定是在神经网络训练完毕后，可以使用下面代码：

    1. public void netStopped(NeuralNetEvent e) {
    2. Monitor mon = (Monitor) e.getSource();
    3. try {
    4. if (mon.isLearning()) {
    5. saveModel(nnet); //序列化对象
    6. }
    7. } catch (IOException ee) {
    8. // TODO Auto-generated catch block
    9. ee.printStackTrace();
    10. }

相关文章