如何利用C++搭建个人专属的TensorFlow

在开始之前，首先看一下最终成型的代码：

创新互联建站是创新、创意、研发型一体的综合型网站建设公司，自成立以来公司不断探索创新，始终坚持为客户提供满意周到的服务，在本地打下了良好的口碑，在过去的十多年时间我们累计服务了上千家以及全国政企客户，如成都LED显示屏等企业单位，完善的项目管理流程，严格把控项目进度与质量监控加上过硬的技术实力获得客户的一致赞美。

1. 分支与特征后端(https://github.com/OneRaynyDay/autodiff/tree/eigen)

2. 仅支持标量的分支(https://github.com/OneRaynyDay/autodiff/tree/master)

这个项目是我与 Minh Le 一起完成的。

为什么?

如果你修习的是计算机科学(CS)的人的话，你可能听说过这个短语「不要自己动手____」几千次了。它包含了加密、标准库、解析器等等。我想到现在为止，它也应该包含了机器学习库(ML library)。

不管现实是怎么样的，这个震撼的课程都值得我们去学习。人们现在把 TensorFlow 和类似的库当作理所当然了。他们把它看作黑盒子并让它运行起来，但是并没有多少人知道在这背后的运行原理。这只是一个非凸(Non-convex)的优化问题!请停止对代码无意义的胡搞——仅仅只是为了让代码看上去像是正确的。

TensorFlow

在 TensorFlow 的代码里，有一个重要的组件，允许你将计算串在一起，形成一个称为「计算图」的东西。这个计算图是一个有向图 G=(V,E)，其中在某些节点处 u1,u2,…,un,v∈V，和 e1,e2,…,en∈E，ei=(ui,v)。我们知道，存在某种计算图将 u1,…,un 映射到 vv。

举个例子，如果我们有 x + y = z，那么 (x,z)，(y,z)∈E。

这对于评估算术表达式非常有用，我们能够在计算图的汇点下找到结果。汇点是类似 v∈V，∄e=(v,u) 这样的顶点。从另一方面来说，这些顶点从自身到其他顶点并没有定向边界。同样的，输入源是 v∈V，∄e=(u,v)。

对于我们来说，我们总是把值放在输入源上，而值也将传播到汇点上。

反向模式求微分

如果你觉得我的解释不正确，可以参考下这些幻灯片的说明。

微分是 Tensorflow 中许多模型的核心需求，因为我们需要它来运行梯度下降。每一个从高中毕业的人都应该知道微分的意思。如果是基于基础函数组成的复杂函数，则只需要求出函数的导数，然后应用链式法则。

超级简洁的概述

如果我们有一个像这样的函数：

对 x 求导：

对 y 求导：

其它的例子：

其导数是：

所以其梯度是：

链式法则，例如应用于 f(g(h(x)))：

在 5 分钟内倒转模式

所以现在请记住我们运行计算图时用的是有向无环结构(DAG/Directed Acyclic Graph)，还有上一个例子用到的链式法则。正如下方所示的形式：

 
 
 
 
      
  
  
  
  1. x -> h -> g -> f 
    2.

作为一个图，我们能够在 f 获得答案，然而，也可以反过来：

 
 
 
 
      
  
  
  
  1. dx <- dh <- dg <- df 
    2.

这样它看起来就像链式法则了!我们需要沿着路径把导数相乘以得到最终的结果。这是一个计算图的例子：

这就将其简化为一个图的遍历问题。有谁察觉到了这就是拓扑排序和深度优先搜索/宽度优先搜索?

没错，为了在两种路径都支持拓扑排序，我们需要包含一套父组一套子组，而汇点是另一个方向的来源。反之亦然。

执行

在开学前，Minh Le 和我开始设计这个项目。我们决定使用特征库后端(Eigen library backend)进行线性代数运算，这个库有一个叫做 MatrixXd 的矩阵类，用在我们的项目中：

 
 
 
 
      
  
  
  
  1. class var {// Forward declarationstruct impl;public: 
    2.   
  
  
  
  2.     // For initialization of new vars by ptr    var(std::shared_ptr); 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4.     var(double); 
    5.   
  
  
  
  5.     var(const MatrixXd&); 
    6.   
  
  
  
  6.     var(op_type, const std::vector&);     
    7.   
  
  
  
  7.     ... 
    8.   
  
  
  
  8.      
    9.   
  
  
  
  9.     // Access/Modify the current node value    MatrixXd getValue() const; 
    10.   
  
  
  
  10.     void setValue(const MatrixXd&); 
    11.   
  
  
  
  11.     op_type getOp() const; 
    12.   
  
  
  
  12.     void setOp(op_type); 
    13.   
  
  
  
  13.      
    14.   
  
  
  
  14.     // Access internals (no modify)    std::vector& getChildren() const; 
    15.   
  
  
  
  15.     std::vector getParents() const; 
    16.   
  
  
  
  16.     ...private:  
    17.   
  
  
  
  17.     // PImpl idiom requires forward declaration of the class:    std::shared_ptr pimpl;};struct var::impl{public: 
    18.   
  
  
  
  18.     impl(const MatrixXd&); 
    19.   
  
  
  
  19.     impl(op_type, const std::vector&); 
    20.   
  
  
  
  20.     MatrixXd val; 
    21.   
  
  
  
  21.     op_type op;  
    22.   
  
  
  
  22.     std::vector children; 
    23.   
  
  
  
  23.     std::vector> parents;};  
    24.

在这里，我们使用了一个叫「pImpl」的语法，意思是「执行的指针」。它有很多用途，比如接口的解耦实现，以及当在堆栈上有一个本地接口时实例化内存堆上的东西。「pImpl」的一些副作用是微弱的减慢运行时间，但是编译时间缩短了很多。这允许我们通过多个函数调用/返回来保持数据结构的持久性。像这样的树形数据结构应该是持久的。

我们有一些枚举来告诉我们目前正在进行哪些操作：

 
 
 
 
      
  
  
  
  1. enum class op_type { 
    2.   
  
  
  
  2.     plus, 
    3.   
  
  
  
  3.     minus, 
    4.   
  
  
  
  4.     multiply, 
    5.   
  
  
  
  5.     divide, 
    6.   
  
  
  
  6.     exponent, 
    7.   
  
  
  
  7.     log, 
    8.   
  
  
  
  8.     polynomial, 
    9.   
  
  
  
  9.     dot, 
    10.   
  
  
  
  10.     ... 
    11.   
  
  
  
  11.     none // no operators. leaf.};  
    12.

执行此树的评估的实际类称为 expression：

 
 
 
 
      
  
  
  
  1. class expression {public: 
    2.   
  
  
  
  2.     expression(var); 
    3.   
  
  
  
  3.     ... 
    4.   
  
  
  
  4.     // Recursively evaluates the tree.    double propagate(); 
    5.   
  
  
  
  5.     ... 
    6.   
  
  
  
  6.     // Computes the derivative for the entire graph.    // Performs a top-down evaluation of the tree.    void backpropagate(std::unordered_map& leaves); 
    7.   
  
  
  
  7.     ...    private: 
    8.   
  
  
  
  8.     var root;};  
    9.

在反向传播里，我们的代码能做类似以下所示的事情：

 
 
 
 
      
  
  
  
  1. backpropagate(node, dprev): 
    2.   
  
  
  
  2.     derivative = differentiate(node)*dprev 
    3.   
  
  
  
  3.     for child in node.children: 
    4.   
  
  
  
  4.         backpropagate(child, derivative)  
    5.

这几乎就是在做一个深度优先搜索(DFS)，你发现了吗?

为什么是 C++?

在实际过程中，C++可能并不适合做这类事情。我们可以在像「Oaml」这样的函数式语言中花费更少的时间开发。现在我明白为什么「Scala」被用于机器学习中，主要就是因为「Spark」。然而，使用 C++有很多好处。

Eigen(库名)

举例来说，我们可以直接使用一个叫「Eigen」的 TensorFlow 的线性代数库。这是一个不假思索就被人用烂了的线性代数库。有一种类似于我们的表达式树的味道，我们构建表达式，它只会在我们真正需要的时候进行评估。然而，使用「Eigen」在编译的时间内就能决定什么时候使用模版，这意味着运行的时间减少了。我对写出「Eigen」的人抱有很大的敬意，因为查看模版的错误几乎让我眼瞎!

他们的代码看起来类似这样的：

 
 
 
 
      
  
  
  
  1. Matrix A(...), B(...); 
    2.   
  
  
  
  2. auto lazy_multiply = A.dot(B); 
    3.   
  
  
  
  3. typeid(lazy_multiply).name(); // the class name is something like Dot_Matrix_Matrix. 
    4.   
  
  
  
  4. Matrix(lazy_multiply); // functional-style casting forces evaluation of this matrix.  
    5.

这个特征库非常的强大，这就是它作为 TensortFlow 主要后端之一的原因，即除了这个慵懒的评估技术之外还有其它的优化。

运算符重载

在 Java 中开发这个库很不错——因为没有 shared_ptrs、unique_ptrs、weak_ptrs;我们得到了一个真实的，有用的图形计算器(GC=Graphing Calculator)。这大大节省了开发时间，更不必说更快的执行速度。然而，Java 不允许操作符重载，因此它们不能这样：

 
 
 
 
      
  
  
  
  1. // These 3 lines code up an entire neural network! 
    2.   
  
  
  
  2. var sigm1 = 1 / (1 + exp(-1 * dot(X, w1))); 
    3.   
  
  
  
  3. var sigm2 = 1 / (1 + exp(-1 * dot(sigm1, w2))); 
    4.   
  
  
  
  4. var loss = sum(-1 * (y * log(sigm2) + (1-y) * log(1-sigm2)));  
    5.

顺便说一下，上面是实际使用的代码。是不是非常的漂亮?我想说的是这甚至比 TensorFlow 里的 Python 封装还更优美!我只是想表明，它们也是矩阵。

在 Java 中，有一连串的 add(), divide() 等等是非常难看的。更重要的是，这将让用户更多的关注在「PEMDAS」上，而 C++的操作符则有非常好的表现。

特征，而不是一连串的故障

在这个库中，可以确定的是，TensorFlow 没有定义清晰的 API，或者有但我不知道。例如，如果我们只想训练一个特定子集的权重，我们可以只对我们感兴趣的特定来源做反向传播。这对于卷积神经网络的迁移学习非常有用，因为很多时候，像 VGG19 这样的大型网络可以被截断，然后附加一些额外的层，这些层的权重使用新领域的样本来训练。

基准

在 Python 的 TensorFlow 库中，对虹膜数据集进行 10000 个「Epochs」的训练以进行分类，并使用相同的超参数，我们有：

  1. TensorFlow 的神经网络： 23812.5 ms
  2. 「Scikit」的神经网络：22412.2 ms
  3. 「Autodiff」的神经网络，迭代，优化：25397.2 ms
  4. 「Autodiff」的神经网络，迭代，无优化：29052.4 ms
  5. 「Autodiff」的神经网络，带有递归，无优化：28121.5 ms

令人惊讶的是，Scikit 是所有这些中最快的。这可能是因为我们没有做庞大的矩阵乘法。也可能是 TensorFlow 需要额外的编译步骤，如变量初始化等等。或者，也许我们不得不在 python 中运行循环，而不是在 C 中(Python 循环真的非常糟糕!)我自己也不是很确定。我完全明白这绝不是一种全面的基准测试，因为它只在特定的情况下应用了单个数据点。然而，这个库的表现并不能代表当前***，所以希望各位读者和我们共同完善。

网页标题：如何利用C++搭建个人专属的TensorFlow
链接分享：http://www.gawzjz.com/qtweb2/news9/12209.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站设计知识

各行业网站

装饰公司网站建设方案　　 　成都定制网站建设　　 　雪茄烟　　 　成都富士康招工　　 　小程序开发　　 　温江做网站公司　　 　成都成品网站　　 　Google外贸推广　　 　郫县封阳台　　 　德阳东方电机技改服务有限公司　　 　成都做手机网站　　 　重庆网站建设　　 　成都微信小程序开发　　 　帝美豪门窗　　 　大足网站建设　　 　成都网站建设　　 　卖友情链接　　 　手机网站建设套餐　　 　成都办公窗帘　　 　四川中建建业