帮助 Neuroph 神经网络

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（刚刚上传），它有一些性能改进。 还有你正在使用哪种训练算法，以及什么设置？您可以尝试动态反向传播。 你的项目听起来很有趣，我真的很抱歉你遇到了 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 中的轻量级 (Nen Beta - 我不知道它与 Neuroph 或 Encog 相比如何，但 performance- and speed-comparison against LibSVM 看起来很有希望。

Answer 5

也许为时已晚，但我也使用 Neuroph。我用我的 SSD 和 4 核 CPU 一夜之间创建了多达 10 万个网络。 当您使用 Java 8 时，您可以在没有高超编码技能的情况下进行多线程。看看 Java 8 的新“Executors”。我在课堂上使用它。看看“MONKEY”对象。请不要介意糟糕的编码风格。我需要在这里快点...

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;
    }

}