Question

我在神经网络中实现反向传播有些麻烦。这个实现是使用Andrew Ng关于Coursera机器学习课程的幻灯片（这里是链接https://www.coursera.org/course/ml）。我认为我已经理解了算法，但代码中存在一些微妙的错误。

我使用的网络有1个输入层，1个隐藏层和1个输出层。它们分别具有2 + 1,2 + 1,1个神经元（+1代表偏差）。当我尝试实现逻辑AND和逻辑OR时，一切都运行良好，并且网络学会了提供正确的值。但后来我试图实现XNOR（XNOR b = NOT（一个XOR b））。

我使用了4个例子：

0 0 1
0 1 0
1 0 0
1 1 1

但突然之间，在这个函数上渐变并没有去任何地方。在开始时，我用随机小数字（从-0.01到0.01）初始化权重。输出接近0.5。然后我做渐变下降。任何输入的输出仍然接近0.5。

我想知道如何解决这个问题。

以下是代码：

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

// contains matrix and Vector classes.
// Vector is just like std::valarray, but is compatible with my matrix.
#include "matrix.hpp" 

size_t L;
std::vector< Vector<double> > layers;
std::vector< matrix<double> > theta;

struct Example
{
    Vector<double> x;
    Vector<double> y;
};

using TrainingSet = std::vector<Example>;

TrainingSet examples;

double g(double x)
{
    return 1 / (1 + exp(-x));
}

void forwardPropagate(Vector<double> x)
{
    for ( size_t i = 1; i < layers[0].size(); ++i )
        layers[0][i] = x[i - 1];

    for ( size_t i = 0; i < L - 1; ++i )
    {
        auto z = theta[i] * layers[i];
        for ( size_t j = 1; j < layers[i + 1].size(); ++j )
            layers[i + 1][j] = g(z[j - 1]);
    }
}

void backwardPropagate(Vector<double> y, std::vector< matrix<double> >& delta)
{
    auto err = layers.back().slice(1) - y;

    for ( int i = L - 2; i >= 0; --i )
    {   
        delta[i] += asMatrix(err) * asMatrix(layers[i]).transpose();

        auto gdz = layers[i] * (Vector<double>(layers[i].size(), 1.0) - layers[i]);
        auto tmp = theta[i].transpose() * err * gdz;
        err = tmp.slice(1);
    }
}

double costFunction(const TrainingSet& examples)
{
    double result = 0.0;

    for ( const auto& example : examples )
    {
        std::cout << layers.back()[1] << '\n';

        forwardPropagate(example.x);
        for ( size_t k = 1; k < layers.back().size(); ++k )
        {
            auto h = layers.back()[k];
            auto y = example.y[k - 1];
            result += y * log(h) + (1 - y) * log(1 - h);
        }
    }

    return (-result) / examples.size();
}

void computeGradient(std::vector< matrix<double> >& delta, const TrainingSet& examples)
{
    for ( auto& m : delta )
        m.fillWith(0);

    for ( auto example : examples )
    {
        forwardPropagate(example.x);
        backwardPropagate(example.y, delta);
    }

    for ( auto& m : delta )
        m /= examples.size();
}

void gradientDescentStep(const std::vector< matrix<double> >& gradient)
{
    const double alpha = 0.01;

    for ( size_t i = 0; i < L - 1; ++i )
        theta[i] -= alpha / examples.size() * gradient[i];
}

double gradientDescent(const TrainingSet& examples)
{
    const double eps = 0.0000001;

    double prev, cur;
    cur = costFunction(examples);

    size_t iterations = 0;
    const size_t max_iterations = 200000000;

    std::vector< matrix<double> > delta;
    delta.reserve(L - 1);
    for ( size_t i = 0; i < L - 1; ++i )
        delta.emplace_back(theta[i].rows(), theta[i].cols());

    do
    {
        prev = cur;
        computeGradient(delta, examples);
        gradientDescentStep(delta);
        cur = costFunction(examples);

    } while ( fabs(cur - prev) >= eps && iterations++ < max_iterations );

    std::cout << "Made " << iterations << " iterations\n";

    return cur;
}

int main()
{
    std::ifstream fin("input.txt");    
    std::istream& in = fin;    

    std::cout.sync_with_stdio(false);

    in >> L;
    std::vector<size_t> architecture(L);

    for ( size_t i = 0; i < L; ++i )
        in >> architecture[i];

    layers.reserve(L);
    for ( size_t i = 0; i < L; ++i )
    {
        layers.emplace_back(1 + architecture[i]);
        layers.back()[0] = 1;
    }

    const double eps = 0.01;    

    theta.reserve(L - 1);
    for ( size_t i = 0; i < L - 1; ++i )
    {
        theta.emplace_back(layers[i + 1].size() - 1, layers[i].size());
        theta[i].randomInitialize(eps);
    }

    size_t number_of_examples;
    in >> number_of_examples;

    examples.reserve(number_of_examples);
    for ( size_t i = 0; i < number_of_examples; ++i )
    {
        auto x = Vector<double>(architecture.front());
        auto y = Vector<double>(architecture.back());

        for ( size_t j = 0; j < architecture.front(); ++j )
            in >> x[j];

        for ( size_t j = 0; j < architecture.back(); ++j )
            in >> y[j];

        examples.emplace_back(Example{x, y});
    }

    for ( auto example : examples )
    {
        forwardPropagate(example.x);
        std::cout << layers.back()[1] << '\n';
    }

    for ( size_t i = 0; i < theta.size(); ++i )
        std::cout << "θ[" << i << "] = " << theta[i];

    gradientDescent(examples);

    for ( size_t i = 0; i < theta.size(); ++i )
        std::cout << "θ[" << i << "] = " << theta[i];

    std::cout << "\n\n\n";

    for ( auto example : examples )
    {
        forwardPropagate(example.x);
        std::cout << layers.back()[1] << '\n';
    }

    return 0;
}

Answer 1

最后我意识到了什么是错的。问题不在于代码本身。问题是这种具有XOR的网络配置的成本函数具有局部最小值。所以，我来到那里并被困住了。

解决方案是在随机方向上迈出一步，直到你超出局部最小值。它允许您非常快地达到全局最小值。

Answer 2

通常对于随机初始化权重在〜[-3,3]的范围内。最初的较大误差量（通过具有较大的权重）有助于“跳跃”权重以收敛到适当的区域。是的，XOR问题具有局部最小值，但您的网络应该能够轻松地收敛到只有少数隐藏节点的正确答案。

你不应该“需要”从局部最小值中取出步骤，它应该很容易收敛到正确的最佳值。网络结构为[2,2,1]的XOR问题具有如此少的权重，您可以相对快速地将权重“随机初始化”到正确的最佳值。（因为搜索空间很小）

注意/编辑如果您的网络只有2个隐藏节点，则会有一个很好的更改，它会卡在本地最小值。即使是大小为[2,7,1]的网络也应该能够在没有随机步骤的情况下收敛。

神经网络中的反向传播算法

2 个答案: