实现属于自己的TensorFlow(一) - 计算图与前向传播

最新推荐文章于 2020-10-28 12:25:48 发布
最新推荐文章于 2020-10-28 12:25:48 发布
阅读量540 收藏 1
点赞数

前言

前段时间因为课题需要使用了一段时间TensorFlow，感觉这种框架很有意思，除了可以搭建复杂的神经网络，也可以优化其他自己需要的计算模型，所以一直想自己学习一下写一个类似的图计算框架。前几天组会开完决定着手实现一个模仿TensorFlow接口的简陋版本图计算框架以学习计算图程序的编写以及前向传播和反向传播的实现。目前实现了前向传播和反向传播以及梯度下降优化器，并写了个优化线性模型的例子。

代码放在了GitHub上，取名SimpleFlow, 仓库链接:

  
  
  1. https://github.com/PytLab/simpleflow

虽然前向传播反向传播这些原理了解起来并不是很复杂，但是真正着手写起来才发现,里面还是有很多细节需要学习和处理才能对实际的模型进行优化(例如Loss函数对每个计算节点矩阵求导的处理)。其中SimpleFlow的代码并没有考虑太多的东西比如dtype和张量size的检查等，因为只是为了实现主要图计算功能并没有考虑任何的优化, 内部张量运算使用的Numpy的接口(毕竟是学习和练手的目的嘛)。

好久时间没更新博客了，在接下来的几篇里面我将把实现的过程的细节总结一下，希望可以给后面学习的童鞋做个参考。

正文

本文主要介绍计算图以及前向传播的实现, 主要涉及图的构建以及通过对构建好的图进行后序遍历然后进行前向传播计算得到具体节点上的输出值。

先贴上一个简单的实现效果吧:

  
  
  1. import simpleflow as sf
  3. # Create a graph
  4. with sf.Graph().as_default():
  5.     a = sf.constant(1.0, name='a')
  6.     b = sf.constant(2.0, name='b')
  7.     result = sf.add(a, b, name='result')
  9.     # Create a session to compute
  10.     with tf.Session() as sess:
  11.         print(sess.run(result))

计算图(Computational Graph)

计算图是计算代数中的一个基础处理方法，我们可以通过一个有向图来表示一个给定的数学表达式，并可以根据图的特点快速方便对表达式中的变量进行求导。而神经网络的本质就是一个多层复合函数, 因此也可以通过一个图来表示其表达式。

本部分主要总结计算图的实现，在计算图这个有向图中，每个节点代表着一种特定的运算例如求和，乘积，向量乘积，平方等等… 例如求和表达式 f(x, y)=x+y 使用有向图表示为:

表达式 f(x,y,z)=z(x+y) 使用有向图表示为:

与TensorFlow的实现不同，为了简化，在SimpleFlow中我并没有定义Tensor类来表示计算图中节点之间的数据流动，而是直接定义节点的类型，其中主要定义了四种类型来表示图中的节点:

1、Operation: 操作节点主要接受一个或者两个输入节点然后进行简单的操作运算，例如上图中的加法操作和乘法操作等。

2、Variable: 没有输入节点的节点，此节点包含的数据在运算过程中是可以变化的。

3、Constant: 类似Variable节点，也没有输入节点，此节点中的数据在图的运算过程中不会发生变化

4、Placeholder: 同样没有输入节点，此节点的数据是通过图建立好以后通过用户传入的

其实图中的所有节点都可以看成是某种操作，其中Variable, Constant, Placeholder都是一种特殊的操作，只是相对于普通的Operation而言，他们没有输入，但是都会有输出（像上图中的xx, yy节点，他们本身输出自身的值到++节点中去），通常会输出到Operation节点，进行进一步的计算。

下面我们主要介绍如何实现计算图的基本组件: 节点和边。

Operation节点

节点表示操作，边代表节点接收和输出的数据，操作节点需要含有以下属性:

1、input_nodes: 输入节点，里面存放与当前节点相连接的输入节点的引用

2、output_nodes: 输出节点, 存放以当前节点作为输入的节点，也就是当前节点的去向

3、outputvalue: 存储当前节点的数值, 如果是Add节点，此变量就存储两个输入节点outputvalue的和

4、name: 当前节点的名称

5、graph: 此节点所属的图 下面我们定义了Operation基类用于表示图中的操作节点(详见https://github.com/PytLab/simpleflow/blob/master/simpleflow/operations.py):

  
  
  1. class Operation(object):
  2.     ''' Base class for all operations in simpleflow.
  3.     An operation is a node in computational graph receiving zero or more nodes
  4.     as input and produce zero or more nodes as output. Vertices could be an
  5.     operation, variable or placeholder.
  6.     '''
  7.     def __init__(self, *input_nodes, name=None):
  8.         ''' Operation constructor.
  9.         :param input_nodes: Input nodes for the operation node.
  10.         :type input_nodes: Objects of `Operation`, `Variable` or `Placeholder`.
  11.         :param name: The operation name.
  12.         :type name: str.
  13.         '''
  14.         # Nodes received by this operation.
  15.         self.input_nodes = input_nodes
  17.         # Nodes that receive this operation node as input.
  18.         self.output_nodes = []
  20.         # Output value of this operation in session execution.
  21.         self.output_value = None
  23.         # Operation name.
  24.         self.name = name
  26.         # Graph the operation belongs to.
  27.         self.graph = DEFAULT_GRAPH
  29.         # Add this operation node to destination lists in its input nodes.
  30.         for node in input_nodes:
  31.             node.output_nodes.append(self)
  33.         # Add this operation to default graph.
  34.         self.graph.operations.append(self)
  36.     def compute_output(self):
  37.         ''' Compute and return the output value of the operation.
  38.         '''
  39.         raise NotImplementedError
  41.     def compute_gradient(self, grad=None):
  42.         ''' Compute and return the gradient of the operation wrt inputs.
  43.         '''
  44.         raise NotImplementedError

在初始化方法中除了定义上面提到的属性外，还需要进行两个操作:

1、将当前节点的引用添加到他输入节点的output_nodes这样可以在输入节点中找到当前节点。

2、将当前节点的引用添加到图中，方便后面对图中的资源进行回收等操作

另外，每个操作节点还有两个必须的方法: computoutput和computegradient. 他们分别负责根据输入节点的值计算当前节点的输出值和根据操作属性和当前节点的值计算梯度。关于梯度的计算将在后续的文章中详细介绍，本文只对节点输出值的计算进行介绍。

下面我以求和操作为例来说明具体操作节点的实现:

  
  
  1. class Add(Operation):
  2.     ''' An addition operation.
  3.     '''
  4.     def __init__(self, x, y, name=None):
  5.         ''' Addition constructor.
  6.         :param x: The first input node.
  7.         :type x: Object of `Operation`, `Variable` or `Placeholder`.
  8.         :param y: The second input node.
  9.         :type y: Object of `Operation`, `Variable` or `Placeholder`.
  10.         :param name: The operation name.
  11.         :type name: str.
  12.         '''
  13.         super(self.__class__, self).__init__(x, y, name=name)
  15.     def compute_output(self):
  16.         ''' Compute and return the value of addition operation.
  17.         '''
  18.         x, y = self.input_nodes
  19.         self.output_value = np.add(x.output_value, y.output_value)
  20.         return self.output_value

可见，计算当前节点output_value的值的前提条件就是他的输入节点的值在此之前已经计算得到了。

Variable节点

与Operation节点类似，Variable节点也需要outputvalue, outputnodes等属性，但是它没有输入节点，也就没有inputnodes属性了，而是需要在创建的时候确定一个初始值initialvalue:

  
  
  1. class Variable(object):
  2.     ''' Variable node in computational graph.
  3.     '''
  4.     def __init__(self, initial_value=None, name=None, trainable=True): 
  5.         ''' Variable constructor.
  6.         :param initial_value: The initial value of the variable.
  7.         :type initial_value: number or a ndarray.
  8.         :param name: Name of the variable.
  9.         :type name: str.
  10.         '''
  11.         # Variable initial value.
  12.         self.initial_value = initial_value
  14.         # Output value of this operation in session execution.
  15.         self.output_value = None
  17.         # Nodes that receive this variable node as input.
  18.         self.output_nodes = []
  20.         # Variable name.
  21.         self.name = name
  23.         # Graph the variable belongs to.
  24.         self.graph = DEFAULT_GRAPH
  26.         # Add to the currently active default graph.
  27.         self.graph.variables.append(self)
  28.         if trainable:
  29.             self.graph.trainable_variables.append(self)
  31.     def compute_output(self):
  32.         ''' Compute and return the variable value.
  33.         '''
  34.         if self.output_value is None:
  35.             self.output_value = self.initial_value
  36.         return self.output_value

Constant节点和Placeholder节点

Constant和Placeholder节点与Variable节点类似，具体实现详见:

  
  
  1. https://github.com/PytLab/simpleflow/blob/master/simpleflow/operations.py

计算图对象

在定义了图中的节点后我们需要将定义好的节点放入到一个图中统一保管，因此就需要定义一个Graph类来存放创建的节点，方便统一操作图中节点的资源。

  
  
  1. class Graph(object):
  2.     ''' Graph containing all computing nodes.
  3.     '''
  4.     def __init__(self):
  5.         ''' Graph constructor.
  6.         '''
  7.         self.operations, self.constants, self.placeholders = [], [], []
  8.         self.variables, self.trainable_variables = [], []

为了提供一个默认的图，在导入simpleflow模块的时候创建一个全局变量来引用默认的图:

  
  
  1. from .graph import Graph
  3. # Create a default graph.
  4. import builtins
  5. DEFAULT_GRAPH = builtins.DEFAULT_GRAPH = Graph()

为了模仿TensorFlow的接口，我们给Graph添加上下文管理器协议方法使其成为一个上下文管理器, 同时也添加一个as_default方法:

  
  
  1. class Graph(object):
  2.     #...
  3.     def __enter__(self):
  4.         ''' Reset default graph.
  5.         '''
  6.         global DEFAULT_GRAPH
  7.         self.old_graph = DEFAULT_GRAPH
  8.         DEFAULT_GRAPH = self
  9.         return self
  11.     def __exit__(self, exc_type, exc_value, exc_tb):
  12.         ''' Recover default graph.
  13.         '''
  14.         global DEFAULT_GRAPH
  15.         DEFAULT_GRAPH = self.old_graph
  17.     def as_default(self):
  18.         ''' Set this graph as global default graph.
  19.         '''
  20.         return self

这样在进入with代码块之前先保存旧的默认图对象然后将当前图赋值给全局图对象，这样with代码块中的节点默认会添加到当前的图中。最后退出with代码块时再对图进行恢复即可。这样我们可以按照TensorFlow的方式来在某个图中创建节点.

Ok，根据上面的实现我们已经可以创建一个计算图了:

  
  
  1. import simpleflow as sf
  3. with sf.Graph().as_default():
  4.     a = sf.constant([1.0, 2.0], name='a')
  5.     b = sf.constant(2.0, name='b')
  6.     c = a * b

前向传播(Feedforward)

实现了计算图和图中的节点，我们需要对计算图进行计算, 本部分对计算图的前向传播的实现进行总结。

会话

首先，我们需要实现一个Session来对一个已经创建好的计算图进行计算，因为当我们创建我们之前定义的节点的时候其实只是创建了一个空节点，节点中并没有数值可以用来计算，也就是output_value是空的。为了模仿TensorFlow的接口，我们在这里也把session定义成一个上下文管理器:

  
  
  1. class Session(object):
  2.     ''' A session to compute a particular graph.
  3.     '''
  4.     def __init__(self):
  5.         ''' Session constructor.
  6.         '''
  7.         # Graph the session computes for.
  8.         self.graph = DEFAULT_GRAPH
  10.     def __enter__(self):
  11.         ''' Context management protocal method called before `with-block`.
  12.         '''
  13.         return self
  15.     def __exit__(self, exc_type, exc_value, exc_tb):
  16.         ''' Context management protocal method called after `with-block`.
  17.         '''
  18.         self.close()
  20.     def close(self):
  21.         ''' Free all output values in nodes.
  22.         '''
  23.         all_nodes = (self.graph.constants + self.graph.variables +
  24.                      self.graph.placeholders + self.graph.operations +
  25.                      self.graph.trainable_variables)
  26.         for node in all_nodes:
  27.             node.output_value = None
  29.     def run(self, operation, feed_dict=None):
  30.         ''' Compute the output of an operation.'''
  31.         # ...

计算某个节点的输出值

上面我们已经可以构建出一个计算图了，计算图中的每个节点与其相邻的节点有方向的联系起来，现在我们需要根据图中节点的关系来推算出某个节点的值。那么如何计算呢? 还是以我们刚才 f(x,y,z)=z(x+y) 的计算图为例,

若我们需要计算橙色 X 运算节点的输出值，我们需要计算与它相连的两个输入节点的输出值，进而需要计算绿色 + 的输入节点的输出值。我们可以通过后序遍历来获取计算一个节点所需的所有节点的输出值。为了方便实现，后序遍历我直接使用了递归的方式来实现:

  
  
  1. def _get_prerequisite(operation):
  2.     ''' Perform a post-order traversal to get a list of nodes to be computed in order.
  3.     '''
  4.     postorder_nodes = []
  6.     # Collection nodes recursively.
  7.     def postorder_traverse(operation):
  8.         if isinstance(operation, Operation):
  9.             for input_node in operation.input_nodes:
  10.                 postorder_traverse(input_node)
  11.         postorder_nodes.append(operation)
  13.     postorder_traverse(operation)
  15.     return postorder_nodes

通过此函数我们可以获取计算一个节点值所需要所有节点列表，再依次计算列表中节点的输出值，最后便可以轻易的计算出当前节点的输出值了。

  
  
  1. class Session(object):
  2.     # ...
  3.     def run(self, operation, feed_dict=None):
  4.         ''' Compute the output of an operation.
  5.         :param operation: A specific operation to be computed.
  6.         :type operation: object of `Operation`, `Variable` or `Placeholder`.
  7.         :param feed_dict: A mapping between placeholder and its actual value for the session.
  8.         :type feed_dict: dict.
  9.         '''
  10.         # Get all prerequisite nodes using postorder traversal.
  11.         postorder_nodes = _get_prerequisite(operation)
  12.         for node in postorder_nodes:
  13.             if type(node) is Placeholder:
  14.                 node.output_value = feed_dict[node]
  15.             else:  # Operation and variable
  16.                 node.compute_output()
  17.         return operation.output_value

例子

上面我们实现了计算图以及前向传播，我们就可以创建计算图计算表达式的值了, 如下:

  
  
  1. import simpleflow as sf
  3. # Create a graph
  4. with sf.Graph().as_default():
  5.     w = sf.constant([[1, 2, 3], [3, 4, 5]], name='w')
  6.     x = sf.constant([[9, 8], [7, 6], [10, 11]], name='x')
  7.     b = sf.constant(1.0, 'b')
  8.     result = sf.matmul(w, x) + b
  10.     # Create a session to compute
  11.     with sf.Session() as sess:
  12.         print(sess.run(result))

输出值:

  
  
  1. array([[  54.,   54.],
  2.        [ 106.,  104.]])

总结

本文使用Python实现了计算图以及计算图的前向传播，并模仿TensorFlow的接口创建了Session以及Graph对象。下篇中将继续总结计算图节点计算梯度的方法以及反向传播和梯度下降优化器的实现。

最后再附上simpleflow项目的链接, 欢迎相互学习和交流:

  
  
  1. https://github.com/PytLab/simpleflow

参考

  
  
  1. Deep Learning From Scratch
  2. https://en.wikipedia.org/wiki/Tree_traversal#Post-order
  3. https://zhuanlan.zhihu.com/p/25496760
  4. http://blog.csdn.net/magic_anthony/article/details/77531552


赞赏作者


本文作者

❈

PytLab，Python 中文社区专栏作者。主要从事科学计算与高性能计算领域的应用，主要语言为Python，C，C++。熟悉数值算法(最优化方法，蒙特卡洛算法等）与并行化 算法（MPI,OpenMP等多线程以及多进程并行化）以及python优化方法，经常使用C++给python写扩展。
知乎专栏：化学狗码砖的日常

blog：http://pytlab.org

github：https://github.com/PytLab

❈

点击阅读原文，加入CodingGo编程社区，更多阅读请点击：

Python中文社区
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算图（computational graph）角度看BP（back propagation）算法
蓁蓁尔的博客
04-15 1万+
从计算图（computational graph）角度看BP（back propagation）算法，这也是目前各大深度学习框架中用到的，Tensorflow, Theano, CNTK等。参考【1】一、通用形式1. 什么是计算图结构 从下图中我们可以清楚地看到 （1）可以将计算图看作是一种用来描述function的语言，图中的节点node代表function的输入（可以是常数、向量、张量等），
计算图
码农ZZK的博客
08-05 563
前言 相信各位做算法的同学都很熟悉框架的使用，但未必很清楚了解我们跑模型的时候，框架内部在做什么，比如怎么自动求导，反向传播。这一系列细节虽然用户不需要关注，但如果 从一道算法题开始 相信有算法基础的同学，应该都知道迪杰斯特拉的双栈算术表达式求和这个经典算法。他的原理是利用两个栈分别存放运算数，操作。根据不同的情况弹出栈里的元素，并进行运算，我们可以具体看下图 这里讨论的是最简单的情况，我们根据操作符的优先级，以及括号的种类(左括号和右括号)，分别进行运算，然后得到最终结果。 神经网络里怎么做？ 在神经网
TensorFlow 架构与设计-编程模型【转】
weixin_33912453的博客
03-01 122
原文：刘光聪·简书   tensorFlow概念 计算图 实战Mnist 分布式Mnist 参考文献　　   　　祝大家在2017年有新的收获。非常感谢大家在春节前夕依然还坚持参加中生代技术的分享活动，也感谢中生代提供的强大的分享平台。 我是刘光聪，来自于中兴通讯技术规划部，关注敏捷软件开发，从事机器学习算法研究，目前负责AI平台架构与设计。 今天我给大家分享的题目是：...
Python-nodefacenet基于TensorFlow用于Nodejs的人脸识别实现
08-09
3. 执行前向传播，将人脸图像转换为向量（embedding）。 4. 计算和比较人脸向量，以确定相似性。 5. 支持批量处理和实时流处理，适应不同的应用场景。 Python在这里的作用主要是数据预处理和模型训练。虽然"node-...
毕设项目：基于PyQT+FaceNet卷积神经网络实现的学生人脸识别考勤系统.zip
08-27
特征提取则是通过模型的前向传播过程，将人脸图像映射为高维特征向量；比对则是计算两个特征向量的欧氏距离，判断是否属于同一个人。 3. **卷积神经网络（CNN）**： 在FaceNet中，卷积神经网络是核心组成部分。CNN...
卷积神经网络结合KNN算法.zip
最新发布
08-28
在学习这个项目时，你需要理解CNN的前向传播过程，包括卷积、激活函数、池化等操作；掌握KNN的基本原理，如距离度量和类别投票；并了解如何将两者结合，进行特征提取和分类。同时，还需要熟悉相关编程语言和库的使用...
MaskRCNN.zip
11-04
Mask R-CNN的核心在于引入了“Mask分支”，与检测分支并行工作，为每个候选框生成一个二值掩模，从而实现了像素级别的分类。 在"Mask_RCNN-master"这个压缩包中，你将找到Mask R-CNN的Python实现，这通常包括以下...
person_search.zip行人检测，跟踪代码
06-30
代码实现过程中，首先需要加载预训练的YOLO模型权重，然后对输入图像进行前向传播，得到每个候选框的置信度和类别概率。置信度表示该框内是否包含行人，类别概率则反映了框内物体属于行人类别的可能性。接着，使用非...
tensorflow 前馈传播代码 python
07-11
tensorflow python 前馈传播代码 ,自己动手完成深度学习前馈传播
前向传播算法的TensorFlow实现
xuesuoziluoshu的博客
01-10 158
本文主要介绍TensorFlow，神经网络前向传播算法具体算法细节默认为已知，在本文中不再赘述，后续可能将会在机器学习原理博文中展开叙述。 本文以一个判断机器零件是否合格的三层神经网络为样例： 该网络有两个输入：x1和x2，一个网络输出：y，W的上标表明了神经网络的层数，下标表明了连接节点编号。在这里假设权重是已知的，给定神经网络的输入，神经网络的结构以及边上的权重，就可以按照图示前向传播算法来...
Computational Graph（计算图）
热门推荐
Zhouxnli 的博客
10-30 2万+
李宏毅深度学习笔记 https://www.bilibili.com/video/av9770302 是什么 一种描述方程的“语言” 既然是图，则有节点（变量），边（操作（简单函数）） 怎么用 结合链式法则可以对给定计算图表示微分 示例： 例如计算e对b的偏微分（等于图中从b到e的所有路径的微分和） 1.计算出图中所有边表示的微分 例如：图中从下至上看，因为c=a+b，因此c对a的偏微分等于...
计算图（Graph）
YQ8023family的博客
02-14 1208
计算图（Graph）介绍 介绍 定义：搭建神经网络的计算过程，只搭建，不运算 神经元的基本模型 y=X1∗W1+X2∗W2 y = X1*W1+X2*W2y=X1∗W1+X2∗W2 X1 X2 W1 W2 输入 分别为X1到y和 X2到y的权重 利用张量运算来描述这个神经元 import tensorflow as tf x = tf.constant([[1.0, ...
图计算
alisonwhite的专栏
10-18 822
第一次接触图计算，有点激动
Tensorflow中前向传播算法
昆仑-郑教主的专栏
07-15 1554
神经网络的前向传播算法主要构成部分：       1.神经网络的输入；       2.神经网络的连接结构；       3.每个神经元中的参数。                  为剪切图，为表示前向传播过程 由输入层的取值推导隐藏层取值，再由隐藏层取值推导输出层取值。 通过矩阵乘法计算前向传播算法： 输入层为
什么是计算图
tugouxp的专栏
10-28 1万+
什么是图： 　按照数据结构的定义，图由顶点集V(G)和边集E(G)组成，记为G=(V,E)。其中E(G)是边的有限集合，边是顶点的无序对（无向图）或有序对（有向图）。 对有向图来说，E(G)是有向边（也称弧(Arc)）的有限集合，弧是顶点的有序对，记为<v,w>，v、w是顶点，v为弧尾（箭头根部），w为弧头（箭头处）。 对无向图来说，E(G)是边的有限集合，边是顶点的无序对，记为(v, w)或者(w, v)，并且(v, w)=(w,v)。 例子： 微信是有向图，因为你钓妹子不成功，.
TensorFlow入门：计算图与会话的使用
计算图是TensorFlow的核心概念，它是一种数据流图，由多个操作（op）组成，这些操作相互连接，表示了计算任务的序列。每个op都有输入和输出，这些输出可以作为其他op的输入，形成一个有向无环图（DAG）。在构建阶段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值