• 很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对AI感兴趣的程序员很快就因其中包含的算法的复杂性而退却。在本文中,我们将讨论一个能大大简化这种复杂性的Java开源工程。 Java面向对象的...

    朋友们,如需转载请标明出处:http://blog.csdn.net/jiangjunshow

     

           很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对AI感兴趣的程序员很快就因其中包含的算法的复杂性而退却。在本文中,我们将讨论一个能大大简化这种复杂性的Java开源工程。

          Java面向对象的神经网络(JOONE)是一开源工程,它提供给Java程序员一个高适应性的神经网络。该JOONE工程源代码由LGPL所保护。简言之,这意味着源代码是可自由使用的而且你不需要支付版税就可以使用JOONE。JOONE可以从http://joone.sourceforge.net/处下载。

          JOONE能允许你轻易地从一个Java程序中创建神经网络。JOONE支持许多特征,如多线程和分布式处理。这意味着JOONE能利用多处理机计算机和多台计算机的优势来进行分布式处理。

      神经网络

      JOONE用Java实现了一个人工神经网络。一个人工神经网络试图仿效生物学神经网络的功能--神经网络组成今天在地球上几乎所有高等生命的大脑形式。神经网络由神经原组成。

    从图1中你可以看出,神经原由一个内核细胞和几个长长的称为触角的连接器组成。神经原之间依靠这些触角进行连接。无论是生物学的还是人工的神经网络,都通过触角把信号从一个神经原传递到另一个神经原来工作。

      使用JOONE

      在这篇文章中,你将看到一个简单的怎样使用JOONE的实例。神经网络题目涉及广泛并覆盖许多不同的应用领域。在本文中,我们将展示给你怎样使用JOONE来解决一个很简单的模式识别问题。模式识别是神经网络中的最普遍的应用之一。

      模式识别提供给神经网络一种模式,判断是否该神经网络能够识别出该模式。这种模式应该能够在某种程度上被扭曲而该神经网络仍然能够识别它。这很像人类识别东西(如一个交通标志)的能力。人类应该能够识别在下雨天,晴天或者晚上的交通标志。即使这些图像看上去可能相当不同,但人类的大脑仍能够判断出它们是一样的图像。

      当进行JOONE编程时,你一般要使用两种类型的对象。你要使用神经原层对象,用于描述一层的一个或多个的具有相似特征的神经原。神经网络经常有一层或两层神经元。这些神经元层通过触角联系在一起。这些触角把这种待识别的模式,从一个神经元层传输到另一个神经元层。

      触角不仅把这种模式从一个神经元层传输到另一个神经元层。触角还将生成一些指向这种模式的元素的斜线。这些斜线将导致这种模式的某些元素在被传输到下一个神经元层时不如通过其它方式传递更有效些。这些斜线通常称为权重,它们形成神经网络的存储系统。通过调整存储在触角中的这些权重,可以更改神经网络的行为。 

      触角在JOONE中还承担着另外一个角色。在JOONE中,可以把触角看作是数据导管。正如触角把模式从一个神经元层传输到另一个神经元层,指定版本的触角用于把模式传入和传出神经网络。下面将给你展示一个简单的单层的神经网络是怎样被构建并进行模式识别的。

    训练神经网络

      为实现本文的目的,我们将指导JOONE去识别一个很简单的模式。在这种模式中,我们将考察一个二进制的布尔操作,例如XOR。这个XOR操作的真值表列举如下:
     

    X

    Y

    X XOR Y

    0 0 0
    0 1 1
    1 0 1
    1 1 0


      正如你从上表中看到的,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%的误差级是可接受的。

     

    训练神经网络

      为实现本文的目的,我们将指导JOONE去识别一个很简单的模式。在这种模式中,我们将考察一个二进制的布尔操作,例如XOR。这个XOR操作的真值表列举如下:
     

    X

    Y

    X XOR Y

    0 0 0
    0 1 1
    1 0 1
    1 1 0


      正如你从上表中看到的,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%的误差级是可接受的。

    展开全文
  • 神经网络java框架学习

    2018-01-19 13:41:10
    1. Java神经网络框架 Neuroph  Neuroph是轻量级的Java神经网络的框架,可以用来模拟常见的神经网络架构。Neuroph包含一个开源的java类库和少量对应基本神经网络概念的基类,以及easyNeurons GUI工具。 Neuroph ...

    1. Java神经网络框架 Neuroph

      Neuroph是轻量级的Java神经网络的框架,可以用来模拟常见的神经网络架构。Neuroph包含一个开源的java类库和少量对应基本神经网络概念的基类,以及easyNeurons GUI工具。
    Neuroph Documentation

    2. 神经网络开源框架 JOONE

      JOONE(Java Object Oriented Neural Network)是sourceforge.net上一个用java语言迅速开发神经网络的开源项目。JOONE支持很多的特性,比如多线程和分布式计算,使用的是BP算法进行迭代计算参数,这意味着可以JOONE可以利用多处理器或是多计算机来均衡负载。
      java版本的神经网络——开源框架JOONE实践


    3. Java神经网络框架 Encog for Java

      Encog是一种先进的神经网络和漫游编程库。 Encog可以单独使用或者建立神经网络或HTTP爬虫程序。集成了支持向量机(SVM)、人工神经网络、遗传算法、贝叶斯网络、隐马尔可夫模型(HMM)、遗传编程和遗传算法。
    ENncog Documentation

    4. 三种框架对比

    Benchmarking and Comparing Encog, Neuroph and JOONE Neural Networks

    Comparing Neural Networks in Neuroph, Encog and JOONE
    - Encog性能更好,中间层算法更丰富,适合实际工程应用
    - Neuroph易于学习,图形界面易操作,适合神经网络初学者理解原理

    5. Encog

    github - encog-java-core

    简单XOR demo

    import org.encog.Encog;
    import org.encog.engine.network.activation.ActivationReLU;
    import org.encog.engine.network.activation.ActivationSigmoid;
    import org.encog.ml.data.MLData;
    import org.encog.ml.data.MLDataPair;
    import org.encog.ml.data.MLDataSet;
    import org.encog.ml.data.basic.BasicMLDataSet;
    import org.encog.neural.networks.BasicNetwork;
    import org.encog.neural.networks.layers.BasicLayer;
    import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
    
    public class XORHelloWorld {
    
        /**
         * 输入数据.
         */
        public static double XOR_INPUT[][] = { { 0.0, 0.0 }, { 1.0, 0.0 },
                { 0.0, 1.0 }, { 1.0, 1.0 } };
    
        /**
         * 期望输出.
         */
        public static double XOR_IDEAL[][] = { { 0.0 }, { 1.0 }, { 1.0 }, { 0.0 } };
    
        /**
         * 主程序.
         */
        public static void main(final String args[]) {
    
            // 创建神经网络.
            BasicNetwork network = new BasicNetwork();
            network.addLayer(new BasicLayer(null,true,2));
            network.addLayer(new BasicLayer(new ActivationReLU(),true,5));
            network.addLayer(new BasicLayer(new ActivationSigmoid(),false,1));
            network.getStructure().finalizeStructure();
            network.reset();
    
            // 创建训练集.
            MLDataSet trainingSet = new BasicMLDataSet(XOR_INPUT, XOR_IDEAL);
    
            // 训练神经网络.
            final ResilientPropagation train = new ResilientPropagation(network, trainingSet);
    
            int epoch = 1;
    
            do {
                train.iteration();
                System.out.println("Epoch #" + epoch + " Error:" + train.getError());
                epoch++;
            } while(train.getError() > 0.01);
            train.finishTraining();
    
            // 测试神经网络.
            System.out.println("Neural Network Results:");
            for(MLDataPair pair: trainingSet ) {
                final MLData output = network.compute(pair.getInput());
                System.out.println(pair.getInput().getData(0) + "," + pair.getInput().getData(1)
                        + ", actual=" + output.getData(0) + ",ideal=" + pair.getIdeal().getData(0));
            }
    
            Encog.getInstance().shutdown();
        }
    }
    展开全文
  • 这是本人的第一篇博客,先给大家分享java、架构师、大数据、人工智能学习路线吧!后续给大家再细化分享学习路线上的细节知识点,希望大家能够持续关注和喜欢! java学习路线 架构师学习路线 多线程与高并发—...

    前言

    这是本人的第一篇博客,先给大家分享java、架构师、大数据、人工智能的学习路线吧!后续给大家再细化分享学习路线上的细节知识点,希望大家能够持续关注和喜欢!

    java学习路线

    架构师学习路线

    多线程与高并发—>深入JVM—>JVM调优案例式实战化指导—>操作系统原理解剖—>网络原理解读—>解读23种设计模式

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    洞悉分布明察井行一路架构冲云霄

    互联网架构演变的过程与原理—>高负载高井发高可用架构设计指导思想—>LVS—>Keepalived—>见流量介入层高性能服务—>zookeeper

    消息中间件—>ELK—>分布式事务—>单点登入—>分布式任务调度—>缓存

    互联网架构演变的过程与原理

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    未来主流必知必会服务微化量绝招(微服务架构)

    RPC构建分布式—>Springboot—>SpringCloud—>Docker—>subernetes—>Service Mesh—>微服务设计的学与思

    Springboot

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    分布存储高效写读优化性能带你飞

    mysql优化—>FastDFS—>OpenResty

    mysql优化

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    团队协作项目管理测试开发-体化

    maven—>Git—>sonarqube—>Jenkins—>JIRA—>FindBugs—>压力测试让你心中有谱

    maven

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    庖丁解牛手写源码一步-步成大牛

    JDK源码解析—>Spring源码解析—>Mybatis源码解析—>SpringMVC源码解析—>Dubbo源码解析—>Netty源码解析

    Spring源码解析

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    46张路线图带你从提高到年薪百万,步步对标阿里P8互联网架构师

     

    价值干万企业实战从此对标CTO

    46张路线å¾å¸¦ä½ ä»æé«å°å¹´èªç¾ä¸ï¼æ­¥æ­¥å¯¹æ é¿éP8äºèç½æ¶æå¸

    大数据学习路线

     

    人工智能

    感谢大家支持,,之后会分享学习路线上面包括的所有知识点,希望大家能够喜欢!!!!

    展开全文
  • 虽然在机器学习中,Python是人工智能从业者使用最多的编程语言,但是,Java 在项目开发中仍然发挥着不可替代的作用,而且许多流行的机器学习框架本身就是 Java编写的。Python 的资料到处都是,而 Java 相关的资料就...

    导读:机器学习是目前盛行于世的技术之一,这几年一时风头无两。虽然在机器学习中,Python是人工智能从业者使用最多的编程语言,但是,Java 在项目开发中仍然发挥着不可替代的作用,而且许多流行的机器学习框架本身就是 Java编写的。Python 的资料到处都是,而 Java 相关的资料就相对少了很多。今天我们翻译了 Fatema Patrawala> 撰写的《六大最常用的 Java 机器学习库一览》。

    MLOSS.org 网站上,列出了 70 多个基于 Java 的开源机器学习项目,可能还有更多未列出的项目,存于大学里的服务器、GitHub 或 Bitbucket 中。我们将在本文中回顾 Java 中的主流机器学习库和平台,它们能够解决的问题类型,支持的算法以及可以使用的数据类型。

    本文节选自 Machine learning in Java,由 Bostjan Kaluza 编写,Packt Publishing Ltd. 出版

    Weka

    Weka 是 Waikato Environment for Knowledge Analysis(Waikato 智能分析环境)的缩写,是新西兰 Waikato 大学开发的机器学习库,也可能是最为有名的 Java 库。Weka 是一个通用的库,能够解决各种机器学习任务,如分类、回归和聚类。它具有丰富的图形用户界面、命令行界面和 Java API。有关 Weka 更多详情,请参阅:http://www.cs.waikato.ac.nz/ml/weka/

    截止到本书写作之时,Weka 总共包含 267 个算法,其中:数据预处理(82),属性选择(33),分类和回归(133),聚类(12),关联规则挖掘(7)。图形界面非常适合用于探索数据,而 Java API 可以让你开发新的机器学习方案并在应用中使用这些算法。
    在这里插入图片描述
    Weka 是在 GNU 通用公共许可证(GNU GPL)下发布的,这意味着你可以复制、分发和修改它,只要你跟踪源文件中的更改并将其保存在 GNU GPL 下。你甚至可以进行商业分发,但前提是你必须公开源代码或获得商业许可证。

    除了几种支持的文件格式外,Weka 还提供了自己的默认数据格式 ARFF,用于通过属性 - 数据对描述数据。它由两部分组成:第一部分包含标题头,它指定所有属性(即特性)及其类型;例如,标称、数字、日期和字符串。第二部分包含数据,其中每行对应于一个实例。标题头中的最后一个属性隐式地被视为目标变量,缺失的数据用问号标记。例如,用 ARFF 文件格式编写的 Bob 实例如下:

        @RELATION person_dataset
        
        @ATTRIBUTE `Name`  STRING
        @ATTRIBUTE `Height`  NUMERIC
        @ATTRIBUTE `Eye color`{blue, brown, green}
        @ATTRIBUTE `Hobbies`  STRING
        
        @DATA
        'Bob', 185.0, blue, 'climbing, sky diving'
        'Anna', 163.0, brown, 'reading'
        'Jane', 168.0, ?, ?
    

    该文件由三个部分组成。第一部分以 @relation 关键字开始,指定数据集名称。下一部分以 @ATTRIBUTE 关键字开始,后面是属性名和类型。可用的类型是 STRING(字符串)、NUMERIC(数字)、DATE(日期)和一组分类值。最后一个属性被隐式假设为我们想要预测的目标变量。最后一部分以 @DATA 关键字开始,每行后面跟着一个实例。实例值用逗号分隔,并且必须遵循与第二部分中的属性相同的顺序。

    Weka 的 Java API 由以下的顶层包组成:

    • weka.associations:这些是关联规则学习的数据结构和算法,包括 Apriori、 predictive apriori、FilteredAssociator、FP-Growth、Generalized Sequential Patterns (GSP)、Hotspot 和 Tertius。

    • weka.classifiers:这些是监督学习算法、评估期和数据结构。该包由以下几个部分组成:

      • weka.classifiers.bayes:它实现了贝叶斯(Bayesian)方法,包括朴素贝叶斯、贝式网络、贝叶斯逻辑回归等。

      • weka.classifiers.evaluation:这些是评价统计、混淆矩阵、ROC 曲线等标称和数值预测的监督评价算法。

      • weka.classifiers.functions:这些是回归算法,包括线性回归、保序回归、高斯过程、支持向量机、多层感知器、表决感知器等。

      • weka.classifiers.lazy:这些是基于实例的算法,比如 k- 最近邻、K*,惰性贝叶斯规则。

      • weka.classifiers.meta:这些是监督学习元算法,包括 AdaBoost、bagging、加性回归、随机委员会(random committee)等。

      • weka.classifiers.mi:这些是多实例算法,如 Citation-KNN、多样性密度、MI AdaBoost 等。

      • weka.classifiers.rules:这些是基于变治法(separate-and-conquer)、Ripper、Part、Prism 的决策表和决策规格。

      • weka.classifiers.trees:这些是各种决策树算法,包括 ID3、C4.5、M5、功能树、逻辑树、随机森林等。

    • weka.clusterers:这些是聚类算法,包括 k-means、Clope、Cobweb、DBSCAN 层次聚类、Farthest 等

    • weka.core:这些是各种实用类、数据表示、配置文件等。

    • weka.datagenerators:这些是用于分类、回归和聚类算法的数据生成器。

    • weka.estimators:这些是用于离散 / 标称域、条件概率估计等的各种数据分布估计。

    • weka.experiment:这是一组类,支持运行实验所需的配置、数据集、模型设置和统计信息。

    • weka.filters:这些是基于属性和基于实例的选择算法,用于监督和非监督数据预处理。

    • weka.gui:这些是实现 Explorer、Experimenter、和 Knowledge Flow 的图形界面。Explorer 允许你调查数据集、算法及其参数,并使用散点图和其他可视化的形式对数据集进行可视化。Experimenter 用于设计批量实验,但它只能用于分类和回归问题。Knowledge Flow 实现了可视化的拖放式用户界面来构建数据流,如:加载数据、应用过滤器、构建分类器和评估。

    用于机器学习的 Java-ML

    Java 机器学习库(Java-ML)是一组机器学习算法的集合,具备用于相同类型的算法的公共接口。它只提供 Java API,因此,它主要面向的是软件工程师和程序员。Java-ML 包含用于数据预处理、特征选择、分类和聚类的算法。此外,它还提供了几个 Weka 桥来直接通过 Java-ML API 访问 Weka 的算法。Java-ML 可从 http://java-ml.sourceforge.net 下载,截至本书完成之际,最近版本发布于 2012 年。
    在这里插入图片描述
    Java-ML 也是一个通用机器学习库。与 Weka 相比,它提供了更为一致的接口和最新算法的实现,在其他包中不存在这些算法,如一系列最先进的相似性度量和特征选择技术等,这些包含动态时间规整、随机森林属性评估等等。Java-ML 也可以在 GNU GPL 许可证下使用。

    Java-ML 支持任何类型的文件,只要它每行包含一个数据样本,并且特征用逗号、分号和制表符分隔。

    Java-ML 库由以下顶层包组成:

    • net.sf.javaml.classification:这些是分类算法,包括朴素贝叶斯、随机森林、Bagging、自组织映射、k- 最近邻等。

    • net.sf.javaml.clustering:这些是聚类算法,包括 kmeans、自组织映射、空间聚类、Cobweb、AQBC 等。

    • net.sf.javaml.core:这些表示实例和数据集。

    • net.sf.javaml.distance:这些是测量实例距离和相似度的算法,如切比雪夫距离(Chebyshev distance)、余弦距离 / 相似度、欧几里得距离(Euclidian distance)、杰卡德距离(Jaccard distance)/ 相似度、马氏距离(Mahalanobis distance)、曼哈顿距离(Manhattan distance)、明氏距离(Minkowski distance)、皮尔逊积矩相关系数(Pearson correlation coefficient)、斯皮尔曼简捷距离(Spearman’s footrule distance)、动态时间规整(dynamic time wrapping,DTW)等。

    • net.sf.javaml.featureselection:这些是用于特征评估、评分、选择和排名的算法,如增益比、ReliefF、Kullback-Liebler 散度、对称不确定性等。

    • net.sf.javaml.filter:这些是通过过滤、删除属性、设置类或属性值等操作实例的方法。

    • net.sf.javaml.matrix:实现内存或基于文件的数组。

    • net.sf.javaml.sampling:实现选择数据集子集的采样算法。net.sf.javaml.tools:这些是关于数据集、实例操作、序列化、Weka API 接口等的使用方法。

    • net.sf.javaml.utils:这些是算法的实用方法,如统计、数学方法、列联表等表等。

    Apache Mahout

    Apache Mahout 项目旨在构建可扩展的机器学习库。它是在可扩展分布式体系结构(如 Hadoop)上构建的,实用 MapReduce 范例,这是一种实用服务器集群处理和生成具有并行分布式算法的大型数据及的方法。
    在这里插入图片描述
    Mahout 提供了控制台界面和 Java API,可用于聚类、分类和写作过滤的可扩展算法。它可以解决这三个业务问题:项目推荐,如向喜欢某部电影的人推荐其他可能喜欢的电影;聚类,如将文本文档分组与主题相关的文档组中归档;分类,如学习将哪个主题分配给未标记的文档。

    Mahout 是在商业化的 Apache 许可证下分发的,这意味着只要你保留 Apache 许可证并将其显示在程序的版权声明中,你就可以使用它。

    Mahout 提供了以下库:
    org.apache.mahout.cf.taste:这些是基于用户和基于项目的协同过滤算法,及基于 ALS 的矩阵分解算法。

    • org.apache.mahout.classifier:这些是内存和分布式实现,包括逻辑回归、朴素贝叶斯、随机森林、隐马尔科夫模型(hidden Markov models,HMM)和多层感知器。

    • org.apache.mahout.clustering:这些是聚类算法,例如 Canopy 聚类、k-means、模糊 k-means、流式 K-means 和谱聚类。

    • org.apache.mahout.common:这些是算法的实用方法,包括距离、MapReduce 操作、迭代器等。

    • org.apache.mahout.driver:实现了通用驱动程序来运行其他类的主要方法。

    • org.apache.mahout.ep:这是使用记录步骤突变的进化优化。

    • org.apache.mahout.math:这些是 Hadoop 中的各种数据额实用方法和实现。

    • org.apache.mahout.vectorizer:这些是用于数据表示、操作和 MapReduce 任务的类。

    Apache Spark

    Apache Spark(或简称 Spark)是在 Hadoop 上构建大规模数据处理的平台,但与 Mahout 不同的是,它与 MapReduce 范式无关。相反,它使用内存缓存提取工作数据集,对其进行处理并重复查询。据报道,Spark 直接处理磁盘存储数据的速度是 Mahout 实现的十倍。可从 https://spark.apache.org 下载。
    在这里插入图片描述
    在 Spark 之上构建了许多模块,例如用于图形处理的 GraphX、用于处理实时数据流的 Spark Streaming 和用于机器学习库的 MLlib,这些模块具有分类、回归、协同过滤、聚类、降维和优化。

    Spark 的 MLlib 可以使用基于 Hadoop 的数据源,例如 Hadoop 分布式文件系统(HDFS)或 HBase,以及本地文件。支持的数据类型包括以下几种:

    • 局部向量存储在一台机器上。稠密向量表示为双类型值数组,如 (2.0,0.0,10.,0.0);而稀疏向量由向量的大小、索引数组和值数组表示,如 [4, (0, 2), (2.0, 1.0)]。

    • 标记点用于监督学习算法,由局部向量组成,用双类型的类值标记。标签可以是类索引、二进制结果或多个类索引的列表(多类分类)。例如,标记的稠密向量表示为 [1.0, (2.0, 0.0, 1.0, 0.0)]。

    • 局部矩阵在单台机器上存储稠密矩阵。它由矩阵维数和以列主序排列的单个双数组定义。

    • 分布式矩阵对存储在 Spark 的弹性分布式数据集(Resilient Distributed Dataset,RDD)中的数据进行操作,RDD 表示可以并行操作的元素集合。有三种表示:行矩阵,其中每一行都是可以存储在一台机器上的局部向量,但行索引没有意义;索引行矩阵,类似于行矩阵,但行索引是有意义的,即可以识别行并执行行连接;坐标矩阵,当行不能存储在一台机器上,且矩阵非常稀疏时才使用。

    Spark 的 MLlib API 库提供了各种学习算法和实用工具的接口,如下所示:

    • org.apache.spark.mllib.classification:这些是二元和多类分类算法,包括线性 SVM、逻辑回归、决策树和朴素贝叶斯。

    • org.apache.spark.mllib.clustering:这些是 k-means 聚类。

    • org.apache.spark.mllib.linalg:这些是数据表示,包括稠密向量、稀疏向量和矩阵。

    • org.apache.spark.mllib.optimization:这是 MLlib 中作为低级基元的各种优化算法,包括梯度下降、随机梯度下降、分布式 SGD 的更新方案和有限内存 BFGS。

    • org.apache.spark.mllib.recommendation:这些是基于模型的协同过滤,通过交替最小二乘矩阵分解来实现。

    • org.apache.spark.mllib.regression:这些是回归学习算法,如线性最小二乘、决策树、Lasso 和 Ridge 回归。

    • org.apache.spark.mllib.stat:这些是稀疏或稠密向量格式的样本的统计函数,用于计算均值、方差、最小值、最大值、计数和非零计数。org.apache.spark.mllib.tree:实现了分类和回归决策树的算法。

    • org.apache.spark.mllib.util:这些是用于加载、保存、预处理、生成和验证数据的方法的集合。

    Deeplearning4j

    DeepLearning4j(或称 DL4J),是一个用 Java 编写的深度学习库。它具有分布式和单机深度学习框架,包括并支持各种神经网络结构,如前馈神经网络、RBM(Restricted Boltzmann Machine,受限玻尔兹曼机)、卷积神经网络、深度信念网络、自动编码器等。DL4J 可以解决不同的问题,比如识别面孔、声音、垃圾邮件和电子商务欺诈。

    Deeplearning4j 也是在 Apache 2.0 许可下分发的,可从 http://deeplearning4j.org 下载。该库由以下组成:

    • org.deeplearning4j.base:这些是加载类。

    • org.deeplearning4j.berkeley:这些是数学使用方法。

    • org.deeplearning4j.clustering:k-means 的聚类实现。

    • org.deeplearning4j.datasets:这是数据集的操作,包括导入、创建、迭代等。

    • org.deeplearning4j.distributions:这是用于分发的实用方法。

    • org.deeplearning4j.eval:这些是评估类,包括混淆矩阵。

    • org.deeplearning4j.exceptions:实现异常处理程序。

    • org.deeplearning4j.models:这些是监督学习算法,包括深度信念网络、堆叠式自动编码器、堆叠去噪式自动编码器和 RBM。

    • org.deeplearning4j.nn:这些是基于神经网络的组件和算法的实现,例如神经网络、多层网络、卷积多层网络等。

    • org.deeplearning4j.optimize:这些是神经网络优化算法,包括反向传播、多层优化、输出层优化等。

    • org.deeplearning4j.plot:这些是用于呈现数据的各种方法。

    • org.deeplearning4j.rng:这是一个随机数据生成器。

    • org.deeplearning4j.util:这些是帮助和实用方法。

    MALLET

    机器学习语言工作包(Machine Learning for Language Toolkit,MALLET),是一个包含自然语言处理算法和实用程序的大型库。它可以用于各种任务,如文档分类、分档聚类、信息提取和主题建模。MALLET 提供了命令行界面和 Java API,适用于多种算法,如朴素贝叶斯、HMM(Hidden Markov Model,隐马尔可夫模型)、隐含狄利克主题模型(Latent Dirichlet topic model)、逻辑回归和条件随机域(conditional random fields)。
    在这里插入图片描述
    MALLET 可以在通用公共许可证 1.0 下使用,这意味着你甚至可以在商业应用程序中使用它。可以从 http://mallet.cs.umass.edu 下载。MALLET 实例由名称、标签、数据和源表示。但是,有两种方法可以将数据导入到 MALLET 格式中,如下所示:

    • Instance per file:每个文件(即文档)对应一个实例,MALLET 接受输入的目录名。

    • Instance per line:每行对应一个实例,假设使用以下格式:instance_name 标签令牌。数据将是一个特征向量,由作为标记出现的不同单词和它们出现次数组成。

    该库由以下包组成:

    • cc.mallet.classify:这些是用于训练和分类实例的算法,包括 AdaBoost、Bagging、C4.5、以及其他决策树模型、多元逻辑回归、朴素贝叶斯和 Winnow2。

    • cc.mallet.cluster:这些是无监督聚类算法,包括贪心凝聚( greedy agglomerative)、爬山算法(hill climbing)、k-best 和 k-means 聚类。

    • cc.mallet.extract:实现分词器(tokenizers)、文档提取器、文档查看器和清理器等。

    • cc.mallet.fst: 实现了序列模型,包括条件随机域、HMM、最大熵马尔科夫模型(maximum entropy Markov models),以及相应的算法和评估器。

    • cc.mallet.grmm:实现了如推理算法、学习和测试的图形模型和因子图。例如环状信念传播(loopy belief propagation)、吉布斯采样(Gibbs sampling)等。

    • cc.mallet.optimize:这些是用于寻找函数最大值的优化算法,例如梯度上升、有限内存 BFGS、随机元上升(stochastic meta ascent)等。

    • cc.mallet.pipe:这些方法是将数据处理为 MALLET 实例中的管道。cc.mallet.topics:这些是主题建模算法,例如隐含狄利克分布(Latent Dirichlet allocation)、四级弹球分布(four-level pachinko allocation)、分层 PAM、DMRT 等。

    • cc.mallet.types:实现了基本数据类型,如数据集、特征向量、实例和标签。

    • cc.mallet.util:这些是各种实用工具功能,如命令行处理、搜索、数学、测试等。

    如果你想利用关键的 Java 机器学习库进行设计、构建和部署你自己的机器学习应用,请查阅 Packt Publishing 出版社出版的《Java 机器学习》(Machine Learning in Java)一书。

    转载自:https://hub.packtpub.com/most-commonly-used-java-machine-learning-libraries/#

    下一步阅读:

    5 JavaScript machine learning libraries you need to know

    A non programmer’s guide to learning Machine learning

    Why use JavaScript for machine learning?

    展开全文
  • java实现人工智能

    2016-05-07 15:30:29
    神经网络[/url] 很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对AI感兴趣的程序员很快就因其中包含的算法的复杂性而退却。在本文中,我们将讨论一个能大大简化这种复杂性的Java开源工程。 ...
    神经网络[/url]   很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对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操作的真值表列举如下: 

    X  Y  X XOR Y 
    0  0  0 
    0  1  1 
    1  0  1 
    1  1 0 


      正如你从上表中看到的,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进行探索提供了一个良好的开端。
    展开全文
  • 25个JAVA机器学习工具包
  • 1. 引言 也许你和这个叫『机器学习』的家伙一点也不熟,但是你举起iphone手机拍照的时候,早已习惯它... 套用一下大神们对机器学习的定义,机器学习研究的是计算机怎样模拟人类的学习行为,以获取新的知识或技能,并重
  • 其中基于深度学习的人机对话交换系统(智能机器人)是人工智能最有潜力的领域,甚至被称作人工智能的皇冠。相对于传统的页面简单交互,人机对话系统更能读懂你的内心世界与想法。 机器人人机对话系统主要涉及深度...
  • OpenCV3.2 Java图像处理视频培训课程:基于OpenCV新版本3.2.0详细讲述Java OpenCV图像处理部分内容,包括Mat对象使用、图像读写、 基于常用核心API讲述基本原理、使用方法、参数、代码演示、图像处理思路与流程讲授...
  • 写过一个Java工程师学习指南,我把它分为了四个部分,第一步是打好Java基础,掌握Java核心技术,第二步是掌握Java Web技术栈,能够做一些项目,第三步是掌握Java方面的进阶技术,包括网络编程、并发编程、JVM等,第...
  • Java工程师学习指南 完结篇 先声明一点,文章里面不会详细到每一步怎么操作,只会提供大致的思路和方向,给大家以启发,如果真的要一步一步指导操作的话,那至少需要一本书的厚度啦。 因为笔者还只是一名在校生,...
  • Java机器学习软件介绍

    2016-10-12 19:49:50
    转自:...在这篇文章中你会发现有关Java中机器学习的主要平台和开放源码库包。 环境 本节描述可用于机器学习java环境或工作台。他们被称为环境,因为他们为执
  • Java学习书籍整理

    2020-05-26 18:02:31
    不知不觉中,做Java开发已经四年了,趁着现在换了工作,还算比较闲,就整理一下自己学习的一些知识。 在学习过程中,我喜欢找的一些电子书来系统化的学习,多数时候我都只是做一个大概的了解,没有深入学习,基本...
  • 在本文中,你会了解Java程序编程如何与人工智能配合使用。 Java的主要特点是Java虚拟机。Java虚拟机是一个抽象机器,可用于许多硬件和软件平台。Java虚拟机执行加载代码,验证代码,提供运行环境和执行代码的操作。...
  • 人工智能-java

    2017-02-28 14:24:15
    神经网络[/url] 很少有程序员不对这里或者那里所包含的人工智能编程所吸引,然而,许多对AI感兴趣的程序员很快就因其中包含的算法的复杂性而退却。在本文中,我们将讨论一个能大大简化这种复杂性的Java开源工程。 ...
  • JAVA学习视频,2018最新全套视频大放送!JAVA学习视频,2018最新全套视频大放送!JAVA学习视频,2018最新全套视频大放送!重要的事情说三遍,小编精心准备的内容。希望对初学者有所帮助! 一、java基础 1.毕向东...
  • Java跨平台行非常强,是编程届的偷拍语言。我们身边只要和互联网、大数据沾点边的行业几乎都离不开java,比如企业软件开发,企业信息管理,手机游戏等全都是基于java实现的。 Java也非常好就业,薪资也恨可观。我国...
  • java学习资源分享

    2018-03-18 21:20:49
    1.Java基础视频  《张孝祥JAVA视频教程》完整版[RMVB](东西网) 历经5年锤炼(史上最适合初学者入门的Java基础视频)(传智播客) 张孝祥2010年贺岁视频:Java高新技术(传智播客) Java多线程与并发库高级应用(传智...
  • 想必不用我强调,大家也清楚2019人工智能学习路线图对大家来说有多重要吧? 在课程方面,目前人工智能的课程制定没有统一的标准,因此不同机构的课程内容是由差别的,有的课程内容多,有的课程内容少,有的课程内容...
1 2 3 4 5 ... 20
收藏数 104,110
精华内容 41,644