Question

对于我的研究生研究，我正在创建一个训练识别图像的神经网络。我要做的不仅仅是采用RGB值网格，下采样，并将它们发送到网络的输入，就像许多例子一样。我实际上使用了超过100个独立训练的神经网络来检测线条，阴影图案等特征。更像人眼，它到目前为止工作得非常好！问题是我有相当多的训练数据。我展示了超过100个汽车外观的例子。然后是100个人的样子。然后超过100个狗的样子，等等。这是相当多的训练数据！目前我在大约一周的时间内开始训练网络。这有点扼杀了我的进步，因为我需要调整和重新训练。

我正在使用Neuroph作为低级神经网络API。我正在运行双四核机器（16个超线程核心），所以这应该很快。我的处理器百分比仅为5％。 Neuroph表现有什么技巧吗？还是Java性能一般？建议？我是一名认知心理博士生，作为一名程序员，我还不错，但对性能编程知之甚少。

Answer 1

是的，几个月前我去了那条路。也适用于大学项目。第一个问题是Neuroph。它致命的慢。 Neuroph很清楚主要的架构和性能问题，上周只有一篇关于代码项目的文章。

http://www.codeproject.com/KB/recipes/benchmark-neuroph-encog.aspx

我遵循了与本文作者类似的路径。从Neuroph切换到Encog是一个非常简单的端口。上面这篇文章的作者甚至还有另一篇文章比较了Encog，JOONE和Neuroph的语法，所以你可以比较一下。有关Encog的更多信息，

http://www.heatonresearch.com/encog

Encog也会更好地利用您的核心。请看上面文章中的图表。

祝你好运！你的研究听起来真棒，我很乐意看到结果。

Answer 2

另请查看您的训练方法。多核可以帮助您更快地完成工作。更聪明的工作也很好。如果你只是使用反向传播，你需要花费很长时间才能收敛。至少使用像弹性传播这样的东西，我认为可能是在Neuroph中。或者看看Scaled Conjugate Gradient或Levenberg Marquardt。 Encog做了这两件事。 Encog还可以使用你的GPU来进一步加速使用OpenCL。

加速迭代很好。但是通过训练迭代进行更多操作通常会更好。做两件事是最好的。

您的神经网络有多独立？老实说，我是主要的Encog程序员，我很乐意看到你切换。但是，如果你处于紧张状态并且需要保持Neuroph并且那些网络真正独立，那么你可能能够产生多个线程并且同时进行多个Neuroph训练循环。覆盖所有核心。假设Neuroph中没有任何东西会在他们的训练师有几次同时出现的情况下出现问题。我不太了解Neuroph，不知道它是如何重入的。

我同意，你的研究听起来很有趣。

Answer 3

您是使用GUI或Java代码进行培训吗？您使用的是哪种版本的Neuroph？如果您正在使用GUI，请使用最新更新版本2.4u1（刚刚上传它），它会有一些性能改进。您还在使用哪种训练算法，以及哪些设置？您可以尝试DynamicBackpropagation。你的项目听起来很有趣，我很抱歉你和Neuroph有问题。在这些基准测试之前，我们并未意识到Neuroph的性能与其他产品相比较低，而且我们将来肯定会对其进行改进。

就像Jeff建议的那样（感谢Jeff），如果您的网络是独立的，您可以这样做：

for(int index = 0; index < numberThreads ; index++ ) {    
    MultiLayerPerceptron mlp = new MultiLayerPerceptron(inputSize, hiddenLayerSize,outputSize);      
    SupervisedLearning learningRule = (SupervisedLearning)mlp.getLearningRule(); 
    learningRule.setMaxError(maxError); 
    learningRule.setMaxIterations(maxIterations); // make sure we can end. 
    learningRule.addObserver(this); // user observer to tell when individual networks are done and launch new networks. 
    this.mlpVector.add(mlp);
    mlp.learnInNewThread(trainingSet);
}

此外，由于您有这么多网络学习参数可能很重要，因此您可以使用Neuroph trainer来确定正确的设置。它尚未完成，但基本上它会生成所有可能的训练设置组合并逐个尝试。希望这对你有所帮助，如果你有更多问题或需要帮助，可以随意询问。

Answer 4

如果您正在寻找Java中的轻量级（<50kb）神经网络实现，您可能还会看一下Nen Beta - 我不知道它与Neuroph或Encog但是performance- and speed-comparison against LibSVM看起来很有希望。

Answer 5

也许为时已晚，但我也使用了Neuroph。我使用我的SSD和4核CPU在夜间创建了数十万个网络。当您使用Java 8时，您可以在没有良好编码技能的情况下进行多线程处理。看看新的＆＃34; Executors＆＃34; Java 8.我在课堂上使用它。看看＆＃34; MONKEY＆＃34;宾语。请不要介意糟糕的编码风格。我需要在这里快点......

package de.sauer.dispe;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.time.Instant;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.data.DataSet;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.util.TransferFunctionType;

import de.sauer.dispe.model.Director;
import de.sauer.dispe.model.Specialist;

@SuppressWarnings("rawtypes")
public class DirBreeder_old {

    private static final int MAX_ITER = 40;
    public static final double GG_EPS = 0.49;
    private static final double[] ERROR_RANGE = {0.02, 0.05, 0.47};
    private static final double[] LEARNING_RANGE = {0.1, 0.1, 0.3};
    private static final int[] LAYER_RANGE = {25, 5, 50};

    private static final TransferFunctionType[] TF_TYPES = {
            TransferFunctionType.GAUSSIAN,
            TransferFunctionType.LOG
        };

    private static final String DIRECTOR_FOLDER = SpecAnalyser.SPEC_PATH+"\\director\\";
    private static final String OUTPUT_SUMMARY_FILE = DIRECTOR_FOLDER+"\\summary.csv";
    private static final String DATASET_FILE = TeamBuilder.TEAM_PATH+"\\1918_train.csv";
    private static ExecutorService MONKEY;

    public static void main(String[] args) throws IOException {
        doStuff();
    }

    public static void doStuff() throws IOException {
        System.out.println("Starting at: "+Instant.now());
        int counter = 0;

        MONKEY = Executors.newFixedThreadPool(4);
        FileWriter output = new FileWriter(new File(OUTPUT_SUMMARY_FILE), true);

        DataSet ds = DataSet.createFromFile(DATASET_FILE, 11, 1, ";");

        for(int firstLayer=LAYER_RANGE[0];firstLayer<=LAYER_RANGE[2];firstLayer+=LAYER_RANGE[1]) {
            for(int secondLayer=LAYER_RANGE[0];secondLayer<=LAYER_RANGE[2];secondLayer+=LAYER_RANGE[1]) { 
                for(int thirdLayer=LAYER_RANGE[0];thirdLayer<=LAYER_RANGE[2];thirdLayer+=LAYER_RANGE[1]) { 
                    for(int forthLayer=LAYER_RANGE[0];forthLayer<=LAYER_RANGE[2];forthLayer+=LAYER_RANGE[1]) { 
                        for(double maxError=ERROR_RANGE[0];maxError<=ERROR_RANGE[2];maxError+=ERROR_RANGE[1]) {
                            for(double learnRate=LEARNING_RANGE[0];learnRate<=LEARNING_RANGE[2];learnRate+=LEARNING_RANGE[1]) {
                                for(TransferFunctionType tft: TF_TYPES) {

                                    Specialist trainee = new Director(
                                            buildAnn(tft, firstLayer, secondLayer, thirdLayer, forthLayer), 
                                            tft, 
                                            maxError, 
                                            ds, 
                                            MAX_ITER, 
                                            GG_EPS, 
                                            learnRate);

                                    MONKEY.execute(new Trainer(trainee, output, counter++));
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println("Building "+counter);
        MONKEY.shutdown();
        try {
            MONKEY.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        output.flush();
        output.close();
    }

    @SuppressWarnings("unchecked")
    private static NeuralNetwork<BackPropagation> buildAnn(TransferFunctionType tft, int layer1, int layer2, int layer3, int layer4) {
        NeuralNetwork nn = new MultiLayerPerceptron(tft, 11, layer1, layer2, layer3, layer4, 1);
        nn.randomizeWeights();
        return nn;
    }

}

帮助Neuroph神经网络

5 个答案: