Artificial intelligence 欧米诺错误获胜'；不减少

我正在创建一个水位预测网络。我在windows上使用的是NeuroPh 2.91。我将网络设置为3个输入，因为它接受3个输入，即水位、降雨量和流入量。我使用多层感知器，tanh作为传递函数，反向传播作为9个隐藏神经元的学习规则

我总是有这样的输出：

Starting neural network training...
Training network try using data set adminshet
Training error: null

根据图表，总网络误差为20000+。

---

我该怎么办？我对安和欧米诺真的很陌生。

我在这里也遇到过同样的问题。类似的设置。它适用于我，我强烈限制最大迭代次数。e、 g.到10岁。 这让我想，神经网络研究中有一个缺陷

简短的提示，对我来说很有用： 自己动手！打开Eclipse，添加一个项目，添加Neuroph JAR并构建您的网络。这很难，但这完全符合预期。您必须将自己的结果转储到csv文件中，并用Excel显示。但是，仅仅通过“点击图形用户界面”是不可行的

package de.sauer.dispe；
导入org.h.core.Layer；
导入org.neuroph.core.NeuralNetwork；
导入org.neuroph.core.Neuron；
导入org.h.core.data.DataSet；
导入org.h.core.transfer.Linear；
导入org.h.core.transfer.Tanh；
导入org.neuroph.nnet.MultiLayerPerceptron；
导入org.h.nnet.learning.BackPropagation；
公共类目录{
专用静态最终int MAX_ITER=2000；
专用静态最终双最大误差=0.005；
私人静态最终双学习率=0.1；
公共静态void main（字符串[]args）{
System.out.println（“创建ANN”）；
神经网络nn=新的多层受体（3,15,15,1）；
//将所有神经元设置为TanH transferfunction（重要，如果有负值）
Layer[]layers=nn.getLayers（）；
用于（层卷曲层：层）{
for（Neuron curNeuron:curLayer.getNeurons（））{
curNeuron.setTransferFunction（new Tanh（））；
}
}
对于（Neuron-curNeuron:layers[3].getNeurons（））{
curNeuron.setTransferFunction（新线性（）；
}
nn.randomizeWeights（）；
System.out.println（“加载采样数据…”）；
DataSet ds=DataSet.createFromFile(
“C:\\Users\\meist\u 000\\Documents\\Thesis\\vanilla\u eng.csv”，
3, 1, ";");
System.out.println（“完成：“+ds.getRows（）.size（）+”.Learn…”）；
//布景
反向传播lr=新反向传播（）；
lr.设置学习率（学习率）；
lr.setMaxIterations（最大迭代次数）；
lr.设置训练集（ds）；
lr.设置神经网络（nn）；
nn.设置学习规则（lr）；
//bla.learn（ds）；更快的批量操作。。。
//较慢的单次日志记录操作：
对于（int i=0；这似乎不是一个编程问题，而是一个如何使用现有程序“Europh”的问题。是的，但如果您没有1500个声誉，就无法添加Europh标记，这就是@jalusa无法添加它的原因，我添加了netbeans，它是Europh背后的IDE。
package de.sauer.dispe;

import org.neuroph.core.Layer;
import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.transfer.Linear;
import org.neuroph.core.transfer.Tanh;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;

public class DirSpeCntrl {

    private static final int MAX_ITER = 2000;
    private static final double MAX_ERROR = 0.005;
    private static final double LEARNING_RATE = 0.1;

    public static void main(String[] args) {
        System.out.println("Create ANN");
        NeuralNetwork<BackPropagation> nn = new MultiLayerPerceptron(3, 15, 15, 1);

        // Setting ALL neurons to TanH transferfunction (important, if you have negativ values)
        Layer[] layers = nn.getLayers();
        for(Layer curLayer: layers) {
            for(Neuron curNeuron: curLayer.getNeurons()) {
                curNeuron.setTransferFunction(new Tanh());
            }
        }

        for(Neuron curNeuron: layers[3].getNeurons()) {
            curNeuron.setTransferFunction(new Linear());
        }

        nn.randomizeWeights();

        System.out.println("Load Sampledata...");
        DataSet ds = DataSet.createFromFile(
                "C:\\Users\\meist_000\\Documents\\Thesis\\vanilla_eng.csv", 
                3, 1, ";");

        System.out.println("done: "+ds.getRows().size()+". Learn...");

        // Setting stuff
        BackPropagation lr = new BackPropagation();
        lr.setLearningRate(LEARNING_RATE);
        lr.setMaxIterations(MAX_ITER);
        lr.setTrainingSet(ds);
        lr.setNeuralNetwork(nn);
        nn.setLearningRule(lr);

//      bla.learn(ds); Faster bulk operation...

        // Slower single operation with logging:
        for(int i=0;i<MAX_ITER;i++) {
            lr.doLearningEpoch(ds);
            double curError = lr.getTotalNetworkError();
            System.out.println(curError);

            if(curError < MAX_ERROR) {
                System.out.println("Stopped on "+i);
                break;
            }
        }

        // Testing the network
        nn.setInput(new double[] {0.080484492, -0.138512128, -0.140826873});
        nn.calculate();
        double[] prediction = nn.getOutput();
        System.out.println("Pred: "+prediction[0]);
    }

}