我一直在尝试创建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);
}
}
}
}
}
我已经从github上其他人的实现中找到了反向传播算法,并尝试使用它,但是我要么得到0.50左右的输出,要么就得到了NaN。如果我使用了错误的算法,以错误的方式或其他方式实现了该算法,我将无法理解。
我正在使用的算法是这样的:首先,我发现了神经元本身的错误:
如果是输出神经元,则NeuronError =(输出神经元的导数)*(预期输出-实际输出)
如果是隐藏神经元,则NeuronError =(隐藏神经元的派生)*(输出神经元的neuronError)*(从隐藏神经元到输出神经元的突触权重)
然后deltaWeight = learningRate *(突触开始的神经元的神经元错误)*(突触开始的神经元的输出)
最后,我将deltaWeight添加到先前的重量。
很抱歉,如果您不阅读代码,那么您至少可以告诉我我的算法是否正确吗?谢谢
您的乙状导数是错误的,应该如下:
public double sigmoidDerivative(double output) {
return output * (1 - output);
}
}
正如我在评论中所说,您输入的火车有两次{1,1},因此请用{0,0}更改一个。
最后,将迭代次数从40增加到100,000。