如何用C++编写不到200行的神经网络

目前已经有许多现成的深度学习框架，为什么我们还要用C++来编写一个神经网络？一个理由是我们需要了解学习框架内部的运行原理，当分析问题的时候能够很快的定位原因；另一个理由是，我们需要为专有设备编写一个推理引擎，它可能运行在手机端，或者移动设备上。这篇文章实现了一个最简单的神经网络框架，适合大家入门学习。

参考代码链接：https://github.com/webbery/MiniEngine/tree/demo

一个最简单的神经网络包含输入节点、一个线性层、一个激活函数和一个损失函数。为了减少编码，我们采用Eigen代替numpy，来实现相关的矩阵操作。

首先定义一个Node节点类作为基类，它包含一个输入节点的队列和一个输出节点的队列；以及当前节点的值，与它连接的反向传播的梯度值，前向传播接口和反向传播接口。另外为了调试方便，我们给Node增加了一个name成员变量，来标识数据对应到哪个节点。

class Node {
public:
　　virtual void forward() = 0;
　　virtual void backward() = 0;
protected:
　　Eigen::MatrixXf _value;
　　std::vector<Node*> _inputs;
　　std::vector<Node*> _outputs;
　　std::map<Node*, Eigen::MatrixXf> _gradients;
　　std::string _name;
};

  输入节点Input继承Node类，代表输入变量，这些变量将被数据赋值。对应于tensorflow的Variable类。这里我们在构造函数里初始化了它的大小row和col

class Input : public Node {
public:
    Input(const char* name,size_t rows=0,size_t cols=0);
};

  Linear节点，代表全连接层，前向传播接口的实现方式为WX+bias，其中bias跟WX计算出来的矩阵形式是不相同的，需要对bias做一个广播操作；反向传播需要计算输出节点对应的W、X、bias梯度值

class Linear : public Node {
public:
    Linear(Node* nodes, Node* weights, Node* bias);

    virtual void forward(){_value = (_nodes->getValue() * _weights->getValue()).rowwise() + Eigen::VectorXf(_bias->getValue()).transpose();}

    virtual void backward(){
　　　　for (auto node : _outputs){
　　　　　　auto grad = node->getGradient(this);
　　　　　　_gradients[_weights] = _nodes->getValue().transpose() * grad;
　　　　　　_gradients[_bias] = grad.colwise().sum().transpose();
　　　　　　_gradients[_nodes] = grad * _weights->getValue().transpose();
　　　　}
　　}

private:
    Node* _nodes = nullptr;
    Node* _weights = nullptr;
    Node* _bias = nullptr;
};

  Sigmoid节点，代表激活函数，前向传播计算sigmoid函数结果，反向传播计算sigmoid导函数

class Sigmoid : public Node {
public:
　　Sigmoid(Node* node);
　　virtual void forward(){_value = _impl(_node->getValue());}
　　virtual void backward(){
　　　　auto y = _value;
　　　　auto y2 = y.cwiseProduct(y);
　　　　_partial = y-y2;

　　　　for (auto node : _outputs) {
　　　　　　auto grad = node->getGradient(this);
　　　　　　_gradients[_node] = grad.cwiseProduct(_partial);
　　　　}
　　}
private:
　　Eigen::MatrixXf _impl(const Eigen::MatrixXf& x){return (-x.array().exp() + 1).inverse();}
private:
　　Node* _node = nullptr;
　　//sigmoid的偏导
　　Eigen::MatrixXf _partial;
};

 MSE节点，代表Loss function，前向传播计算估计值与真实值的方差，反向传播需要计算方差的一阶导数结果

class MSE : public Node {
public:
　　MSE(Node* y, Node* y_hat);
　　virtual void forward(){
　　　　_diff = _y->getValue() - _y_hat->getValue();
　　　　auto diff2= _diff.cwiseProduct(_diff);
　　　　auto v = Eigen::MatrixXf(1, 1);
　　　　v << (diff2).mean();
　　　　_value = v;
　　}
　　virtual void backward(){
　　　　auto r = _y_hat->getValue().rows();
　　　　_gradients[_y] = _diff * (2.f / r);
　　　　_gradients[_y_hat] = _diff * (-2.f / r);
　　}
private:
　　Node* _y;
　　Node* _y_hat;
　　Eigen::MatrixXf _diff;
};

 这几个节点是我们将要构建的框架的基本元素。然后我们还需要实现一个图的拓扑排序，对排序后的节点进行前向迭代，计算预测结果；然后再反向迭代，计算每个连接的梯度。

std::vector<Node*> topological_sort(Node* input_nodes){
　　//根据传入的数据初始化图结构
　　Node* pNode = nullptr;
　　//pair第一个为输入,第二个为输出
　　std::map < Node*, std::pair<std::set<Node*>, std::set<Node*> > > g;
　　//待遍历的周围节点
　　std::list<Node*> vNodes;
　　vNodes.emplace_back(input_nodes);
　　//广度遍历,先遍历输出节点,再遍历输入节点
　　//已经遍历过的节点
　　std::set<Node*> sVisited;
　　while (vNodes.size() && (pNode = vNodes.front())) {
　　　　if (sVisited.find(pNode) != sVisited.end()) vNodes.pop_front();
　　　　const auto& outputs = pNode->getOutputs();
　　　　for (auto item: outputs){
　　　　　　g[pNode].second.insert(item);    //添加item为pnode的输出节点
　　　　　　g[item].first.insert(pNode);    //添加pnode为item的输入节点
　　　　　　if(sVisited.find(item)==sVisited.end()) vNodes.emplace_back(item);    //把没有访问过的节点添加到待访问队列中
　　　　}
　　　　const auto& inputs = pNode->getInputs();
　　　　for (auto item: inputs){
　　　　　　g[pNode].first.insert(item);    //添加item为pnode的输入节点
　　　　　　g[item].second.insert(pNode);    //添加pnode为item的输出节点
　　　　　　if (sVisited.find(item) == sVisited.end()) vNodes.emplace_back(item);
　　　　}
　　　　sVisited.emplace(pNode);
　　　　vNodes.pop_front();
　　}

　　//根据图结构进行拓扑排序
　　std::vector<Node*> vSorted;
　　while (g.size()) {
　　　　for (auto itr=g.begin();itr!=g.end();++itr)
　　　　{
　　　　　　//没有输入节点
　　　　　　auto& f = g[itr->first];
　　　　　　if (f.first.size() == 0) {
　　　　　　　　vSorted.push_back(itr->first);
　　　　　　　　//找到图中这个节点的输出节点，然后将输出节点对应的这个父节点移除
　　　　　　　　auto outputs = f.second;//f['out']
　　　　　　　　for (auto& output: outputs) g[output].first.erase(itr->first);
　　　　　　　　//然后将这个节点从图中移除
　　　　　　　　g.erase(itr->first);
　　　　　　　　break;
　　　　　　}
　　　　}
　　}
　　return vSorted;
}

 测试程序中，我们定义了每个节点，并构造了节点之间的连接关系；之后把输入节点传给了topological_sort。该函数从输入节点开始，进行广度优先遍历，构建一个图结构；然后根据拓扑排序算法，将这个图结构排序成一个队列返回；这个队列在tensorflow里被称为“图”。

然后，测试程序运行train_one_batch前向遍历一次得到预测值，然后再反向遍历一次，得到每个节点连接的梯度变化；

void train_one_batch(std::vector<Node*>& graph){
　　for (auto node:graph){
　　　　node->forward();
　　}
　　for (int idx = graph.size() - 1; idx >= 0;--idx) {
　　　　graph[idx]->backward();
　　}
}

 接着根据计算出来的梯度值，更新权重节点W，b，完成一次训练

void sgd_update(std::vector<Node*> update_nodes, float learning_rate){
　　for (auto node: update_nodes){
　　　　Eigen::MatrixXf delta = -1 * learning_rate * node->getGradient(node);
　　　　node->setValue(node->getValue() + delta);
　　}
}