Java 有人能检查一下我的xor神经网络代码有什么问题吗

我一直在尝试创建一个XOR神经网络，但对于所有输入，输出总是收敛到某个值（如1、0或0.5）。这是我的最新尝试：

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        double[][] trainingInputs = {
                {1, 1},
                {1, 0},
                {0, 1},
                {1, 1}
        };
        double[] targetOutputs = {0, 1, 1, 0};
        NeuralNetwork network = new NeuralNetwork();
        System.out.println("Training");
        for(int i=0; i<40; i++) {
            network.train(trainingInputs, targetOutputs);
        }
        for(double[] inputs : trainingInputs) {
            double output = network.feedForward(inputs);
            System.out.println(inputs[0] + " - " + inputs[1] + " : " + output);
        }
    }
}

class Neuron {
    private ArrayList<Synapse> inputs; // List di sinapsi collegate al neurone
    private double output; // output del neurone
    private double derivative; // derivata dell'output
    private double weightedSum; // somma ponderata del peso delle sinapsi e degli output collegati
    private double error; // errore
    public Neuron() {
        inputs = new ArrayList<Synapse>();
        error = 0;
    }
    // Aggiunge una sinpapsi
    public void addInput(Synapse input) {
        inputs.add(input);
    }

    public List<Synapse> getInputs() {
        return this.inputs;
    }

    public double[] getWeights() {
        double[] weights = new double[inputs.size()];

        int i = 0;
        for(Synapse synapse : inputs) {
            weights[i] = synapse.getWeight();
            i++;
        }

        return weights;
    }

    private void calculateWeightedSum() {
        weightedSum = 0;
        for(Synapse synapse : inputs) {
            weightedSum += synapse.getWeight() * synapse.getSourceNeuron().getOutput();
        }
    }

    public void activate() {
        calculateWeightedSum();
        output = sigmoid(weightedSum);
        derivative = sigmoidDerivative(output);
    }

    public double getOutput() {
        return this.output;
    }

    public void setOutput(double output) {
        this.output = output;
    }

    public double getDerivative() {
        return this.derivative;
    }

    public double getError() {
        return error;
    }

    public void setError(double error) {
        this.error = error;
    }

    public double sigmoid(double weightedSum) {
        return 1 / (1 + Math.exp(-weightedSum));
    }

    public double sigmoidDerivative(double output) {
        return output / (1 - output);
    }
}

class Synapse implements Serializable {

    private Neuron sourceNeuron; // Neurone da cui origina la sinapsi
    private double weight; // Peso della sinapsi

    public Synapse(Neuron sourceNeuron) {
        this.sourceNeuron = sourceNeuron;
        this.weight = Math.random() - 0.5;
    }

    public Neuron getSourceNeuron() {
        return sourceNeuron;
    }

    public double getWeight() {
        return weight;
    }

    public void adjustWeight(double deltaWeight) {
        this.weight += deltaWeight;
    }
}

class NeuralNetwork implements Serializable {
    Neuron[] input;
    Neuron[] hidden;
    Neuron output;
    double learningRate = 0.1;
    public NeuralNetwork() {
        input = new Neuron[2];
        hidden = new Neuron[2];
        output = new Neuron();
        for(int i=0; i<2; i++) {
            input[i] = new Neuron();
        }
        for(int i=0; i<2; i++) {
            hidden[i] = new Neuron();
        }
        for(int i=0; i<2; i++) {
            Synapse s = new Synapse(hidden[i]);
            output.addInput(s);
        }
        for(int i=0; i<2; i++) {
            for(int j=0; j<2; j++) {
                Synapse s = new Synapse(input[j]);
                hidden[i].addInput(s);
            }
        }
    }
    public void setInput(double[] inputVal) {
        for(int i=0; i<2; i++) {
            input[i].setOutput(inputVal[i]);
        }
    }
    public double feedForward(double[] inputVal) {
        setInput(inputVal);
        for(int i=0; i<2; i++) {
            hidden[i].activate();
        }
        output.activate();
        return output.getOutput();
    }
    public void train(double[][] trainingInputs, double[] targetOutputs) {
        for(int i=0; i<4; i++) {
            double[] inputs = trainingInputs[i];
            double target = targetOutputs[i];
            double currentOutput = feedForward(inputs);
            double delta = 0;
            double neuronError = 0;
            for(int j=0; j<2; j++) {
                Synapse s = output.getInputs().get(j);
                neuronError = output.getDerivative() * (target - currentOutput);
                delta = learningRate * s.getSourceNeuron().getOutput() * neuronError;
                output.setError(neuronError);
                s.adjustWeight(delta);
            }
            for(int j=0; j<2; j++) {
                for(int k=0; k<2; k++) {
                    Synapse s = hidden[j].getInputs().get(k);
                    Synapse s1 = output.getInputs().get(j);
                    delta = learningRate * s.getSourceNeuron().getOutput() * hidden[j].getDerivative() * s1.getWeight() * output.getError();
                    s.adjustWeight(delta);
                }
            }
        }
    }
}

import java.io.*；
导入java.util.*；
公共班机{
公共静态void main（字符串[]args）{
双[][]训练输入={
{1, 1},
{1, 0},
{0, 1},
{1, 1}
};
double[]targetOutput={0,1,1,0}；
NeuralNetwork=新的NeuralNetwork（）；
系统输出打印（“培训”）；
对于（int i=0；i您的乙状结肠导数是错误的，应如下所示：

public double sigmoidDerivative(double output) {
        return output * (1 - output);
    }
}

正如我在评论中所说，你的火车输入中有{1,1}两次，
所以用{0，0}改变一个

最后，将迭代次数从40次增加到100000次。
您的乙状结肠导数错误，应如下所示：

public double sigmoidDerivative(double output) {
        return output * (1 - output);
    }
}

正如我在评论中所说，你的火车输入中有{1,1}两次，
所以用{0，0}改变一个

最后，将迭代次数从40次增加到100000次。
我认为40次迭代次数太少了，你能试试100000次吗？要检查这个，你可以在
adjustWeight
方法中打印
deltaWeight/this.weight
，看看你的调整是否很小。每当我尝试多次迭代时，程序就会开始输出NaN。但是我会试试deltaWeight/this.weight谢谢。我已经四处查看了一些，我认为除了小重量更新之外还有另一个问题。另外，您的火车输入应该包括{0，0}是的，那是我的错误。我试图更改训练输入和目标输出，以查看结果是否会更改，但当我问这个问题时，我忘了将它们更改回去。我认为40次迭代次数太少了，您能否尝试100000次以确定？要检查此项，您可以在
调整权重
中打印
增量权重/this.weight
方法来查看您的调整是否非常小。每当我尝试多次迭代时，程序就会开始输出NaN。但我将尝试deltaWeight/this.weight谢谢。我已经四处查看了一些，我认为除了小权重更新之外还有另一个问题。您的训练输入也应该包括{0，0}是的，那是我的错误。我试图改变培训投入和目标产出，看看结果是否会改变，但当我问这个问题时，我忘了把它们改回来。非常感谢，现在它终于起作用了。我已经尝试了两周，我不敢相信这个错误。编辑：我想给你一个投票但我的名声还不到15岁。很高兴我能帮上忙：）。我确实认为在某些地方仍然存在一个小错误，因为如果你尝试多次，结果并不总是应该的。非常感谢你，现在它终于起作用了。我已经尝试了两个星期，我不敢相信这个错误。编辑：我想给你一个提升投票，但我的声誉还不到15。很高兴我可以帮助：）。我确实认为在某些地方仍然存在一个小错误，因为如果你尝试多次，结果并不总是应该的。