如何用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);
　　}
}