我无法理解反向传播算法。我读了很多书，也搜索了很多书，但我不明白为什么我的神经网络不起作用。我想确认我做的每一部分都是正确的。
这是我的神经网络，当它被初始化并且第一行输入 [1, 1] 和输出 [0] 被设置时(如你所见，我正在尝试做 XOR 神经网络):
我有 3 层:输入层、隐藏层和输出层。第一层(输入)和隐藏层包含 2 个神经元，每个神经元有 2 个突触。最后一层(输出)包含一个神经元和 2 个突触。
一个突触包含一个权重和它的前一个增量(在开始时，它是 0)。连接到突触的输出可以在与突触关联的 sourceNeuron 中找到，如果没有 sourceNeuron(如在输入层中)，则可以在输入数组中找到。
Layer.java 类包含一个神经元列表。在我的 NeuralNetwork.java 中，我初始化神经网络，然后在我的训练集中循环。在每次迭代中，我替换输入和输出值并在我的反向传播算法上调用 train，该算法针对当前集合运行一定次数的时间(目前为 1000 次纪元)。
我使用的激活函数是 sigmoid。
训练集和验证集是(输入1，输入2，输出):
1,1,0
0,1,1
1,0,1
0,0,0
这是我的 Neuron.java 实现:
public class Neuron {
private IActivation activation;
private ArrayList<Synapse> synapses; // Inputs
private double output; // Output
private double errorToPropagate;
public Neuron(IActivation activation) {
this.activation = activation;
this.synapses = new ArrayList<Synapse>();
this.output = 0;
this.errorToPropagate = 0;
}
public void updateOutput(double[] inputs) {
double sumWeights = this.calculateSumWeights(inputs);
this.output = this.activation.activate(sumWeights);
}
public double calculateSumWeights(double[] inputs) {
double sumWeights = 0;
int index = 0;
for (Synapse synapse : this.getSynapses()) {
if (inputs != null) {
sumWeights += synapse.getWeight() * inputs[index];
} else {
sumWeights += synapse.getWeight() * synapse.getSourceNeuron().getOutput();
}
index++;
}
return sumWeights;
}
public double getDerivative() {
return this.activation.derivative(this.output);
}
[...]
}
Synapse.java 包含:
public Synapse(Neuron sourceNeuron) {
this.sourceNeuron = sourceNeuron;
Random r = new Random();
this.weight = (-0.5) + (0.5 - (-0.5)) * r.nextDouble();
this.delta = 0;
}
[... getter and setter ...]
我的类(class) BackpropagationStrategy.java 中的 train 方法运行一个 while 循环并在训练集的一行 1000 次(epoch)后停止。它看起来像这样:
this.forwardPropagation(neuralNetwork, inputs);
this.backwardPropagation(neuralNetwork, expectedOutput);
this.updateWeights(neuralNetwork);
下面是上述方法的所有实现(learningRate = 0.45 and momentum = 0.9):
public void forwardPropagation(NeuralNetwork neuralNetwork, double[] inputs) {
for (Layer layer : neuralNetwork.getLayers()) {
for (Neuron neuron : layer.getNeurons()) {
if (layer.isInput()) {
neuron.updateOutput(inputs);
} else {
neuron.updateOutput(null);
}
}
}
}
public void backwardPropagation(NeuralNetwork neuralNetwork, double realOutput) {
Layer lastLayer = null;
// Loop à travers les hidden layers et le output layer uniquement
ArrayList<Layer> layers = neuralNetwork.getLayers();
for (int i = layers.size() - 1; i > 0; i--) {
Layer layer = layers.get(i);
for (Neuron neuron : layer.getNeurons()) {
double errorToPropagate = neuron.getDerivative();
// Output layer
if (layer.isOutput()) {
errorToPropagate *= (realOutput - neuron.getOutput());
}
// Hidden layers
else {
double sumFromLastLayer = 0;
for (Neuron lastLayerNeuron : lastLayer.getNeurons()) {
for (Synapse synapse : lastLayerNeuron.getSynapses()) {
if (synapse.getSourceNeuron() == neuron) {
sumFromLastLayer += (synapse.getWeight() * lastLayerNeuron.getErrorToPropagate());
break;
}
}
}
errorToPropagate *= sumFromLastLayer;
}
neuron.setErrorToPropagate(errorToPropagate);
}
lastLayer = layer;
}
}
public void updateWeights(NeuralNetwork neuralNetwork) {
for (int i = neuralNetwork.getLayers().size() - 1; i > 0; i--) {
Layer layer = neuralNetwork.getLayers().get(i);
for (Neuron neuron : layer.getNeurons()) {
for (Synapse synapse : neuron.getSynapses()) {
double delta = this.learningRate * neuron.getError() * synapse.getSourceNeuron().getOutput();
synapse.setWeight(synapse.getWeight() + delta + this.momentum * synapse.getDelta());
synapse.setDelta(delta);
}
}
}
}
对于验证集，我只运行这个:
this.forwardPropagation(neuralNetwork, inputs);
然后在我的输出层检查神经元的输出。
我做错了什么吗？需要一些解释...
这是我在 1000 个纪元后的结果:
Real: 0.0
Current: 0.025012156926937503
Real: 1.0
Current: 0.022566830709341495
Real: 1.0
Current: 0.02768416343491415
Real: 0.0
Current: 0.024903432706154027
为什么输入层的突触没有更新？到处都是只更新隐藏层和输出层。
如您所见，这是完全错误的!它不会只到第一个训练集输出 (0.0) 到 1.0。
更新 1
这是使用此集合在网络上进行的一次迭代:[1.0,1.0,0.0]。这是前向传播方法的结果:
=== Input Layer
== Neuron #1
= Synapse #1
Weight: -0.19283583155573614
Input: 1.0
= Synapse #2
Weight: 0.04023817185601586
Input: 1.0
Sum: -0.15259765969972028
Output: 0.461924442180935
== Neuron #2
= Synapse #1
Weight: -0.3281099260608612
Input: 1.0
= Synapse #2
Weight: -0.4388250065958519
Input: 1.0
Sum: -0.7669349326567131
Output: 0.31714251453174147
=== Hidden Layer
== Neuron #1
= Synapse #1
Weight: 0.16703288052854093
Input: 0.461924442180935
= Synapse #2
Weight: 0.31683996162148054
Input: 0.31714251453174147
Sum: 0.17763999229679783
Output: 0.5442935820534444
== Neuron #2
= Synapse #1
Weight: -0.45330313978424686
Input: 0.461924442180935
= Synapse #2
Weight: 0.3287014377113835
Input: 0.31714251453174147
Sum: -0.10514659949771789
Output: 0.47373754172497556
=== Output Layer
== Neuron #1
= Synapse #1
Weight: 0.08643751629154495
Input: 0.5442935820534444
= Synapse #2
Weight: -0.29715579267218695
Input: 0.47373754172497556
Sum: -0.09372646936373039
Output: 0.47658552081912403
更新 2
我可能有偏见问题。我将在这个答案的帮助下进行调查:Role of Bias in Neural Networks .它不会在下一个数据集移回，所以...
最佳答案
终于找到问题了。对于 XOR，我不需要任何偏差，它正在收敛到预期值。当您四舍五入最终输出时，我得到了准确的输出。需要的是训练然后验证，然后再次训练直到神经网络令人满意。我训练每组直到满意为止，但不是一次又一次地训练整组。
// Initialize the Neural Network
algorithm.initialize(this.numberOfInputs);
int index = 0;
double errorRate = 0;
// Loop until satisfaction or after some iterations
do {
// Train the Neural Network
algorithm.train(this.trainingDataSets, this.numberOfInputs);
// Validate the Neural Network and return the error rate
errorRate = algorithm.run(this.validationDataSets, this.numberOfInputs);
index++;
} while (errorRate > minErrorRate && index < numberOfTrainValidateIteration);
对于真实数据，我需要一个偏差，因为输出开始出现分歧。这是我添加偏差的方法:
在 Neuron.java 类中，我添加了一个偏置突触，其权重和输出为 1.0。我将它与所有其他突触相加，然后将其放入我的激活函数中。
public class Neuron implements Serializable {
[...]
private Synapse bias;
public Neuron(IActivation activation) {
[...]
this.bias = new Synapse(this);
this.bias.setWeight(0.5); // Set initial weight OR keep the random number already set
}
public void updateOutput(double[] inputs) {
double sumWeights = this.calculateSumWeights(inputs);
this.output = this.activation.activate(sumWeights + this.bias.getWeight() * 1.0);
}
[...]
在 BackPropagationStrategy.java 中，我在重命名为 updateWeightsAndBias 的 updateWeights 方法中更改了权重和每个偏差的增量。
public class BackPropagationStrategy implements IStrategy, Serializable {
[...]
public void updateWeightsAndBias(NeuralNetwork neuralNetwork, double[] inputs) {
for (int i = neuralNetwork.getLayers().size() - 1; i >= 0; i--) {
Layer layer = neuralNetwork.getLayers().get(i);
for (Neuron neuron : layer.getNeurons()) {
[...]
Synapse bias = neuron.getBias();
double delta = learning * 1.0;
bias.setWeight(bias.getWeight() + delta + this.momentum * bias.getDelta());
bias.setDelta(delta);
}
}
}
[...]
有了真实的数据，网络正在收敛。找到学习率、动量、错误率、神经元数量、隐藏层数量等的完美变量组合(如果可能的话)现在是一项修剪工作。
关于java - 难以理解神经网络中的反向传播算法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27280750/