用joone来快速建立神经网络系统(补全
来源:互联网 发布:玻璃尺寸计算软件 编辑:程序博客网 时间:2024/04/26 04:50
用joone来快速建立神经网络系统
简介
很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对AI感兴趣的程序员很快就因其中包含的算法的复杂性而退却。在本文中,我们将讨论一个能大大简化这种复杂性的Java开源工程。
Java面向对象的神经网络(JOONE) 是一开源工程,它提供给Java程序员一个高适应性的神经网络。该JOONE工程源代码由LGPL所保护。简言之,这意味着源代码是可自由使用的而且你不 需要支付版税就可以使用JOONE。JOONE可以从http://joone.sourceforge.net/处下载。
JOONE能允许你轻易地从一个Java程序中创建神经网络。JOONE支持许多特征,如多线程和分布式处理。这意味着JOONE能利用多处理机计算机和多台计算机的优势来进行分布式处理。
神经网络
JOONE用Java实现了一个人工神经网络。一个人工神经网络试图仿效生物学神经网络的功能--神经网络组成今天在地球上几乎所有高等生命的大脑形式。神经网络由神经原组成。图1显示了一个实际神经原图。
图1:一个生物学的神经原
从图1中你可以看出,神经原由一个内核细胞和几个长长的称为触角的连接器组成。神经原之间依靠这些触角进行连接。无论是生物学的还是人工的神经网络,都通过触角把信号从一个神经原传递到另一个神经原来工作。
使用JOONE
在这篇文章中,你将看到一个简单的怎样使用JOONE的实例。神经网络题目涉及广泛并覆盖许多不同的应用领域。在本文中,我们将展示给你怎样使用JOONE来解决一个很简单的模式识别问题。模式识别是神经网络中的最普遍的应用之一。
模 式识别提供给神经网络一种模式,判断是否该神经网络能够识别出该模式。这种模式应该能够在某种程度上被扭曲而该神经网络仍然能够识别它。这很像人类识别东 西(如一个交通标志)的能力。人类应该能够识别在下雨天,晴天或者晚上的交通标志。即使这些图像看上去可能相当不同,但人类的大脑仍能够判断出它们是一样 的图像。
当进行JOONE编程时,你一般要使用两种类型的对象。你要使用神经原层对象,用于描述一层的一个或多个的具有相似特征的神经原。神经网络经常有一层或两层神经元。这些神经元层通过触角联系在一起。这些触角把这种待识别的模式,从一个神经元层传输到另一个神经元层。
触 角不仅把这种模式从一个神经元层传输到另一个神经元层。触角还将生成一些指向这种模式的元素的斜线。这些斜线将导致这种模式的某些元素在被传输到下一个神 经元层时不如通过其它方式传递更有效些。这些斜线通常称为权重,它们形成神经网络的存储系统。通过调整存储在触角中的这些权重,可以更改神经网络的行为。
触角在JOONE中还承担着另外一个角色。在JOONE中,可以把触角看作是数据导管。正如触角把模式从一个神经元层传输到另一个神经元层,指定版本的触角用于把模式传入和传出神经网络。下面将给你展示一个简单的单层的神经网络是怎样被构建并进行模式识别的。
训练神经网络
为实现本文的目的,我们将指导JOONE去识别一个很简单的模式。在这种模式中,我们将考察一个二进制的布尔操作,例如XOR。这个XOR操作的真值表列举如下:
正如你从上表中看到的,XOR运算的结果是只有当X和Y具有不同值时,结果才为真(1)。其它情况下,XOR运算结果均为假(0)。默认 地,JOONE从存储在你的系统中的文本文件中取得输入。这些文本文件通过使用一种称为FileInputSynapse的特殊触角来读取。为了训练 XOR运算问题,你必须建立一个输入文件-该文件包含上面显示的数据。该文件显示在列表1中。
列表1:为解决XOR问题的输入文件的内容
0.0;0.0;0.0
0.0;1.0;1.0
1.0;0.0;1.0
1.0;1.0;0.0
我 们现在分析一个简单的程序,它指导JOONE来识别XOR运算并产生正确的结果。我们现在分析训练该神经网络必须被处理的过程。训练过程包括把XOR问题 提交给神经网络,然后观察结果。如果这个结果不是所预期的,该训练算法将调整存储在触角中的重量。在神经网络的实际输出和预料的输出之间的差距称为误差。 训练将继续到误差小于一个可接受值为止。这个级别通常是一个百分数,如10%。我们现在分析必须用于训练一个神经网络的代码。
训练过程通过建立神经网络开始,同时也必须创建隐蔽的输入层和输出层。
// 首先,创造这三个层
input = new SigmoidLayer();
hidden = new SigmoidLayer();
output = new SigmoidLayer();
每个层被使用JOONE对象SigmoidLayer创建。Sigmoidlayer基于自然对数生成一个输出。JOONE还包含另外的层,而不是你可能选择使用的S形的层类型。
下一步,每一层被赋于一个名字。这些名字将有助于后面在调试期间识别该层。
input.setLayerName("input");
hidden.setLayerName("hidden");
output.setLayerName("output");
现在必须定义每个层。我们将指定在每一层中的"行"号。该"行"号对应于这一层中的神经原的数目。
input.setRows(2);
hidden.setRows(3);
output.setRows(1);
从上面的代码看出,输入层有两个神经原,隐蔽层有三个隐蔽神经原,输出层包含一个神经原。这对于神经网络包含两个输入神经原和一个输出神经原是具有重要意义的,因为XOR运算符接收两个参数而产生一个结果。
为使用该神经原层,我们也必须创建触角。在本例中,我们要使用多个触角。这些触角用下面的代码实现。
// 输入-> 隐蔽的连接。
FullSynapse synapse_IH = new FullSynapse();
// 隐蔽-> 输出连接。
FullSynapse synapse_HO = new FullSynapse();
就象神经原层的情况一样,触角也可能命名以有助于程序的调试。下面的代码命名新建的触角。
synapse_IH.setName("IH");
synapse_HO.setName("HO");
最后,我们必须把触角联接到适当神经原层。下面的代码实现这一点。
// 联接输入层到隐蔽层
input.addOutputSynapse(synapse_IH);
hidden.addInputSynapse(synapse_IH);
// 联接隐蔽层到输出层
hidden.addOutputSynapse(synapse_HO);
output.addInputSynapse(synapse_HO);
现在既然神经网络已被创建,我们必须创建一个用于调节该神经网络的监视器对象。下面的代码创建监视器对象。
//创建监视器对象并且设置学习参数
monitor = new Monitor();
monitor.setLearningRate(0.8);
monitor.setMomentum(0.3);
学习速度和动力作为参数以用于指定训练的产生方式。JOONE利用backpropagation学习算法。要更多了解关于学习速度或者动力的信息,你应该参考backpropagation算法。
这个监视器对象应该被赋值给每一个神经原层。下面的代码实现这一点。
input.setMonitor(monitor);
hidden.setMonitor(monitor);
output.setMonitor(monitor);
就象许多Java对象本身一样,JOONE监视器允许听者可以添加到它上面去。随着训练的进行,JOONE将通知听者有关训练进程的信息。在这个简单的例子中,我们使用:
monitor.addNeuralNetListener(this);
我们现在必须建立输入触角。如前所述,我们将使用一个FileInputSynapse来读取一个磁盘文件。磁盘文件不是JOONE唯一 能够接受的输入种类。JOONE对于不同的输入源具有很强的灵活性。为使JOONE能够接收其它输入类型,你只需创建一个新的触角来接受输入。在本例中, 我们将简单地使用FileInputSynapse。FileInputSynapse首先被实例化。
inputStream = new FileInputSynapse();
然后,必须通知FileInputSynapse要使用哪些列。列表1中显示的文件使用了输入数据的前两列。下面代码建立起前两列用于输入到神经网络。
// 前两列包含输入值
inputStream.setFirstCol(1);
inputStream.setLastCol(2);
然后,我们必须提供输入文件的名字,这个名字直接来源于用户接口。然后,提供一个编辑控件用于收集输入文件的名字。下面代码为FileInputSynapse设置文件名。
// 这是包含输入数据的文件名
inputStream.setFileName(inputFile.getText());
如前所述,一个触角仅是一个神经原层之间的数据导管。FileInputSynapse正是这里的数据导管,通过它数据进入到神经网络。为了更容易实现这点,我们必须要把FileInputSynapse加到神经网络的输入层。这由下面一行实现。
input.addInputSynapse(inputStream);
现在既然已经建立起神经网络,我们必须创建一个训练员和一个监视器。训练员用于训练该神经网络,因为该监视器通过一个事先设置好的训练重 复数来运行这个神经网络。对于每一次训练重复,数据被提供到神经网络,然后就可以观察到结果。该神经网络的权重(存储在穿梭在神经原层之间的触角连接中) 将根据误差作适当调整。随着训练的进行,误差级将下降。下列代码建立训练员并把它依附到监视器。
trainer = new TeachingSynapse();
trainer.setMonitor(monitor);
你会记得列表1中提供的输入文件包含三个列。到目前为止,我们仅仅使用了第一、二列,它们指定了到神经网络的输入。第三列包含当提供给神 经网络第一列中的数字时的期盼的输出值。我们必须使得训练员能够存取该列以便能确定误差。该错误是神经网络的实际输出和期盼的输出之间的差距。下列代码创 建另外一个FileInputSynapse并作好准备以读取与前面相同的输入文件。
// 设置包含期望的响应值的文件,这由FileInputSynapse来提供
samples = new FileInputSynapse();
samples.setFileName(inputFile.getText());
这时,我们想指向在第三列的FileInputSynapse。下列代码实现了这一点,然后让训练员使用这个FileInputSynapse。
//输出值在文件中的第三列上
samples.setFirstCol(3);
samples.setLastCol(3);
trainer.setDesired(samples);
最后,训练员被连结到神经网络输出层,这将使训练员接收神经网络的输出。
// 连接训练员到网络的最后一层
output.addOutputSynapse(trainer);
我们现在已为所有的层准备好后台线程,包括训练员。
input.start();
hidden.start();
output.start();
trainer.start();
最后,我们为训练设置一些参数。我们指定在输入文件中共有四行,而且想训练20,000个周期,而且还在不段学习。如果你设置学习参数为false,该神经网络将简单地处理输入并不进行学习。我们将在下一节讨论输入处理。
monitor.setPatterns(4);
monitor.setTotCicles(20000);
monitor.setLearning(true);
现在我们已经为训练过程作好准备。调用监视器的Go方法将在后台启动训练过程。
monitor.Go();
神经网络现在将要被训练20,000个周期。当神经网络训练完成,误差层应该在一个合理的低级别上。一般低于10%的误差级是可接受的。
运行神经网络
现在,既然神经网络已经训练开始,我们可以通过提供输入模式给神经网络来测试它并 观察结果。用于运行神经网络的方法必须首先为神经网络处理数据作好准备。目前,该神经网络处理一种训练方式中。首先,我们将从输出层删除训练员。然后,我 们将用FileOutputSynapse替换训练员,以便于我们能记录来自于神经网络的输出。下面的代码实现这一点:
output.removeOutputSynapse(trainer);
FileOutputSynapse results = new FileOutputSynapse();
results.setFileName(resultFile.getText());
现在我们必须重置输入流--我们将使用与训练期间一样的文件输入流。这将填入在神经网络训练期间使用的相同的输入。
inputStream.resetInput();
samples.resetInput();
results.setMonitor(monitor);
output.addOutputSynapse(results);
然后,我们必须重启响应于该神经网络所有的线程。
input.start();
hidden.start();
output.start();
trainer.start();
现在,既然线程已被重新启动,我们必须为下一步的识别设置一些基本配置信息。下面代码完成这些工作。
monitor.setPatterns(4);
monitor.setTotCicles(1);
monitor.setLearning(false);
首先,输入模式数要置为4,这是因为我们想要神经网络处理所有这四种输入模式(你以前为训练该神经网络提供的)。最后,置为学习方式。这些完成后,我们可以调用监视器的"Go"方法。
monitor.Go();
当训练完成,你将看到输出文件产生的结果类似列表2。
列表2:来自于神经网络的输出
0.012549763955262739
0.9854631848890223
0.9853159647305264
0.01783622084836082
可以看出,上面列表中的第一行中的数字合理地接近于零。这是很好的,因为输入训练文件的第一行,如列表1所示,被预期结果是为零的。同样,第二行合理地接近于1,这也很好,因为训练文件的第二行被预期结果也是为1的。
结论
JOONE 引擎封装了神经网络编程中的具有相当多的复杂性,本文的例子显示了神经网络使用的基本过程。尽管真实世界中神经网络的实现将复杂得多,但是其基本处理过程 是一样的--数据被提供到神经网络用于训练,然后生成新的模式用于识别。这里的例程为用JOONE进行探索提供了一个良好的开端。
后记:joone提供了一个editor可以在gui的界面里面很快的开发出神经网络系统。由于我也是刚开始学习,推荐这个开源程序给大家。以后我也会发表更多的原创。希望大家多多交流
程序原代吗如下:import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import org.joone.engine.*;
import org.joone.engine.learning.*;
import org.joone.io.*;
/**
* Example: The XOR Problem with JOONE
*
* @author Jeff Heaton
* @version 1.0
*/
public class XorExample extends JFrame implements
ActionListener,NeuralNetListener {
FullSynapse t1,t2;
/**
* The train button.
*/
JButton btnTrain;
/**
* The run button.
*/
JButton btnRun;
/**
* The quit button.
*/
JButton btnQuit;
/**
* The name of the input file.
*/
JTextField inputFile;
/**
* The name of the result file.
*/
JTextField resultFile;
/**
* The status line.
*/
JLabel status;
/**
* Constructor. Set up the components.
*/
public XorExample()
{
setTitle("XOR Solution");
Container content = getContentPane();
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
content.setLayout(gridbag);
c.fill = GridBagConstraints.NONE;
c.weightx = 1.0;
// Training input label
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
new JLabel(
"Enter the name of the training input
file:"),c);
// Training input filename
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
inputFile = new JTextField(40),c);
inputFile.setText("./train.txt");
// Training input label
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
new JLabel("Enter the name of the result file:")
,c);
// Training input filename
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
resultFile = new JTextField(40),c);
resultFile.setText("./result.txt");
// the button panel
JPanel buttonPanel = new JPanel(new FlowLayout());
buttonPanel.add(btnTrain = new JButton("Train"));
buttonPanel.add(btnRun = new JButton("Run"));
buttonPanel.add(btnQuit = new JButton("Quit"));
btnTrain.addActionListener(this);
btnRun.addActionListener(this);
btnQuit.addActionListener(this);
// Add the button panel
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.CENTER;
content.add(buttonPanel,c);
// Training input label
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
status = new JLabel("Click train to begin
training..."),c);
// adjust size and position
pack();
Toolkit toolkit = Toolkit.getDefaultToolkit();
Dimension d = toolkit.getScreenSize();
setLocation(
(int)(d.width-this.getSize().getWidth())/2,
(int)(d.height-this.getSize().getHeight())/2 );
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
setResizable(false);
}
/**
* The main function, just display the JFrame.
*
* @param args No arguments are used.
*/
public static void main(String args[])
{
(new XorExample()).show(true);
}
/**
* Called when the user clicks one of the three
* buttons.
*
* @param e The event.
*/
public void actionPerformed(ActionEvent e)
{
if ( e.getSource()==btnQuit )
System.exit(0);
else if ( e.getSource()==btnTrain )
train();
else if ( e.getSource()==btnRun )
run();
}
/**
* Called when the user clicks the run button.
*/
protected void run()
{
output.removeOutputSynapse(trainer);
inputStream.resetInput();
samples.resetInput();
FileOutputSynapse results = new FileOutputSynapse();
results.setFileName(resultFile.getText());
results.setMonitor(monitor);
output.addOutputSynapse(results);
input.start();
hidden.start();
output.start();
trainer.start();
// number of rows (patterns) contained in the input file
monitor.setPatterns(4);
// How many times the net must be trained on the input
// patterns
monitor.setTotCicles(1);
// The net must be trained
monitor.setLearning(false);
// The net starts the training job
monitor.Go();
status.setText("Results written to " + resultFile.getText());
}
/**
* The input layer of neurons.
*/
SigmoidLayer input;
/**
* The hidden layer of neurons.
*/
SigmoidLayer hidden;
/**
* The output layer of neurons.
*/
SigmoidLayer output;
/**
* The monitor. Used to pass parameters to all of the
* JOONE objects.
*/
Monitor monitor;
/**
* The file input stream.
*/
FileInputSynapse inputStream;
/**
* Used to train the neural network.
*/
TeachingSynapse trainer;
/**
* The training data.
*/
FileInputSynapse samples;
/**
* Called when the user clicks the train button.
*/
protected void train()
{
// First, creates the three Layers
input = new SigmoidLayer();
hidden = new SigmoidLayer();
output = new SigmoidLayer();
input.setLayerName("input");
hidden.setLayerName("hidden");
output.setLayerName("output");
// sets their dimensions
input.setRows(2);
hidden.setRows(3);
output.setRows(1);
// Now create the two Synapses
// input -> hidden conn.
FullSynapse synapse_IH = new FullSynapse();
// hidden -> output conn.
FullSynapse synapse_HO = new FullSynapse();
synapse_IH.setName("IH");
synapse_HO.setName("HO");
t1=synapse_IH;
t2=synapse_HO;
// Connect the input layer with the hidden layer
input.addOutputSynapse(synapse_IH);
hidden.addInputSynapse(synapse_IH);
// Connect the hidden layer with the output layer
hidden.addOutputSynapse(synapse_HO);
output.addInputSynapse(synapse_HO);
// Create the Monitor object and set the learning parameters
monitor = new Monitor();
monitor.setLearningRate(0.8);
monitor.setMomentum(0.3);
// Pass the Monitor to all components
input.setMonitor(monitor);
hidden.setMonitor(monitor);
output.setMonitor(monitor);
// The application registers itself as monitor's listener
// so it can receive the notifications of termination from
// the net.
monitor.addNeuralNetListener(this);
inputStream = new FileInputSynapse();
// The first two columns contain the input values
inputStream.setFirstCol(1);
inputStream.setLastCol(2);
// This is the file that contains the input data
inputStream.setFileName(inputFile.getText());
input.addInputSynapse(inputStream);
trainer = new TeachingSynapse();
trainer.setMonitor(monitor);
// Setting of the file containing the desired responses,
// provided by a FileInputSynapse
samples = new FileInputSynapse();
samples.setFileName(inputFile.getText());
// The output values are on the third column of the file
samples.setFirstCol(3);
samples.setLastCol(3);
trainer.setDesired(samples);
// Connects the Teacher to the last layer of the net
output.addOutputSynapse(trainer);
// All the layers must be activated invoking their method
// start; the layers are implemented as Runnable objects, then
// they are allocated on separated threads. The threads will
// stop after training and will need to be restarted later.
input.start();
hidden.start();
output.start();
trainer.start();
// number of rows (patterns) contained in the input file
monitor.setPatterns(4);
// How many times the net must be trained on the input
// patterns
monitor.setTotCicles(20000);
// The net must be trained
monitor.setLearning(true);
// The net starts the training job
monitor.Go();
}
/**
* JOONE Callback: called when the neural network
* stops. Not used.
*
* @param e The JOONE event
*/
public void netStopped(NeuralNetEvent e) {
}
/**
* JOONE Callback: called to update the progress
* of the neural network. Used to update the
* status line.
*
* @param e The JOONE event
*/
public void cicleTerminated(NeuralNetEvent e) {
Monitor mon = (Monitor)e.getSource();
long c = mon.getCurrentCicle();
long cl = c / 1000;
// print the results every 1000 cycles
if ( (cl * 1000) == c )
status.setText(c + " cycles remaining - Error = "
+ mon.getGlobalError());
}
/**
* JOONE Callback: Called when the network
* is starting up. Not used.
*
* @param e The JOONE event.
*/
public void netStarted(NeuralNetEvent e) {
}
}
About the Author
Jeff Heaton is the author of Programming Spiders, Bots, and Aggregators in Java (Sybex, 2002). Jeff works as a software designer for the Reinsurance Group of America. Jeff has written three books and numerous magazine articles about computer programming. Jeff may be contacted through his Web site, http://www.jeffheaton.com.
原文网址:http://www.developer.com/java/other/article.php/10936_1546201_1- 用joone来快速建立神经网络系统(补全
- 基于JOONE快速开发神经网络
- 基于JOONE快速开发神经网络
- 基于JOONE快速开发神经网络
- 基于JOONE快速开发神经网络
- 基于 JOONE 快速开发神经网络 (Java)
- Joone项目实现神经网络
- JOONE-神经网络 java api
- java-joone神经网络算法
- 神经网络 JAVA工具包 joone 例程
- 神经网络开发包joone的功能演示
- 基于开源JOONE 神经网络实例
- 用XP系统来建立VPN服务器
- eclipse代码快速补全设置
- Android Postfix Completion快速补全插件
- IntelliJ快速补全for循环:fori
- Android Postfix Completion快速补全插件
- unity3D之道具系统补全
- Class和URLClassLoader
- !DOCTYPE 说明
- OpenCms 7 Development book 下载
- 5个8都齐了,应该没事了。 ~~~
- C# ,webBrowser,登录,数据填充,模拟点击链接,运行JS函数
- 用joone来快速建立神经网络系统(补全
- webwork里面List迭代数据字典Map中数据!
- 深入浅出之正则表达式
- 在Oracle中使用序列创建唯一流水号
- 黑客开发出思科路由器后门
- 关于在VISIO中进行数据库建模时如何显示字段类型,以及注释的
- 我爱你中国,我爱你中华民族
- 自己写的操作 RMS类
- uclinux-2008r1-rc8(bf561)的中断处理(4):_evt_ivhw