C++ 神经网络：反向传播

我已经为这个挠头很久了。。。基本上我在尝试做神经网络反向传播训练

我相信我的误差反向传播是正确的；但它似乎没有正确训练我的神经网络

template<class T, class U>
class Backpropagation {
public:
  static void train(std::shared_ptr<NeuralNetworkFeedForwardLayered<T, U> > neural_network, std::valarray<double> input, std::valarray<double> label, double eta = 0.10) {
    std::valarray<double> output;

    // go forward and calculate our values
    neural_network->f(input, output);

    // error at output nodes
    std::valarray<double> error = label - output;

    std::vector<std::shared_ptr<Neuron> > neurons = neural_network->get_outputs();

        // set the error to our neurons
    for (std::vector<std::shared_ptr<Neuron> >::size_type i = 0; i < neurons.size(); i++) {
      std::shared_ptr<NeuronBackpropagation> neuron = std::dynamic_pointer_cast<NeuronBackpropagation>(neurons[i]);

      neuron->set_error(error[i]);
    }

    // backpropagate our errors
    for (typename std::vector<std::shared_ptr<NeuronLayer<T> > >::size_type i = neural_network->get_layers_count() - 2; i <= neural_network->get_layers_count(); i--) {
      // go through each neuron in the layer
      std::shared_ptr<NeuronLayer<T> > layer = neural_network->get_layer(i);

      for (typename std::vector<std::shared_ptr<Neuron> >::size_type j = 0; j < layer->get_neurons_count(); j++) {
        std::shared_ptr<NeuronBackpropagation> neuron = std::dynamic_pointer_cast<NeuronBackpropagation>(layer->get_neuron(j));

        double sum = 0;

        std::vector<std::shared_ptr<Synapse> > connections = neuron->get_synapse_outputs();
        for (typename std::vector<std::shared_ptr<Synapse> >::size_type k = 0; k < connections.size(); k++) {
          std::shared_ptr<NeuronBackpropagation> post = std::dynamic_pointer_cast<NeuronBackpropagation>(connections[k]->get_neuron_post());
          sum += connections[k]->w() * post->get_error();
            }

        neuron->set_error(neuron->d() * sum);
      }
    }

    // now its time to calculate our derivative (dw) and update our weights
    for (typename std::vector<std::shared_ptr<NeuronLayer<T> > >::size_type i = 0; i < neural_network->get_layers_count(); i++) {
      std::shared_ptr<NeuronLayer<T> > layer = neural_network->get_layer(i);

      for (typename std::vector<std::shared_ptr<Neuron> >::size_type j = 0; j < layer->get_neurons_count(); j++) {
        std::shared_ptr<NeuronBackpropagation> neuron = std::dynamic_pointer_cast<NeuronBackpropagation>(layer->get_neuron(j));
        std::vector<std::shared_ptr<Synapse> > connections = neuron->get_synapse_inputs();

        double error = neuron->get_error();
        for (typename std::vector<std::shared_ptr<Synapse> >::size_type k = 0; k < connections.size(); k++) {
          std::shared_ptr<Neuron> pre = connections[k]->get_neuron_pre();
          // std::cout << "set_weight: " << connections[i]->w() + alpha * error * pre->f() << " " << error << " " << pre->f() << std::endl;

          connections[k]->set_weight(connections[k]->w() + eta * error * pre->f());
        }
      }
    }
  }

};

模板
类反向传播{
公众：
静态无效序列（标准：：共享ptr神经网络，标准：：VALARY输入，标准：：VALARY标签，双eta=0.10）{
std：：阵列输出；
//继续计算我们的价值
神经网络->f（输入、输出）；
//输出节点出错
std:：VALARY error=标签-输出；
向量神经元=神经网络->获取输出（）；
//将错误设置为我们的神经元
对于（std:：vector:：size_type i=0；i设置错误（错误[i]）；
}
//反向传播我们的错误
对于（typename std:：vector:：size_type i=neural_network->get_layers_count（）-2；i get_layers_count（）；i--）{
//检查该层中的每个神经元
std:：shared\u ptr layer=神经网络->获取层（i）；
对于（typename std:：vector:：size_type j=0；jget_neurons_count（）；j++）{
std:：shared_ptr neuron=std:：dynamic_pointer_cast（层->获取_neuron（j））；
双和=0；
向量连接=神经元->获取突触输出（）；
对于（typename std:：vector:：size_type k=0；kget_neuron_post（））；
sum+=connections[k]->w（）*post->get_error（）；
}
神经元->设置错误（神经元->d（）*sum）；
}
}
//现在是计算导数（dw）和更新权重的时候了
对于（typename std:：vector:：size_type i=0；iget_layers_count（）；i++）{
std:：shared\u ptr layer=神经网络->获取层（i）；
对于（typename std:：vector:：size_type j=0；jget_neurons_count（）；j++）{
std:：shared_ptr neuron=std:：dynamic_pointer_cast（层->获取_neuron（j））；
向量连接=神经元->获取突触输入（）；
双重错误=神经元->获取错误（）；
对于（typename std:：vector:：size_type k=0；kget_neuron_pre（）；
//std：：cout f（）如果你能给我们提供比普通代码更多的信息，你会有很多想法。你的输入看起来怎么样？你用参考实现训练过吗？中间结果正确吗？用AND/OR/XOR案例进行测试。使用2个输入节点、4个隐藏节点和1个输出节点。中间结果是什么意思？谢谢。你说你假设错误反向传播是正确的，但是你能确认这一点吗？如果反向传播是正确的，那么错误必须在权重更新范围内。我真的认为你应该用参考实现一步一步地检查你的算法。