TensorFlow算子融合

TensorFlow算子融合

• TensorFlow的特点：
  • 真正的可移植性
    • 引入各种计算设备的支持，包括CPU，GPU，以及能够很好的运行在各种系统的移动端
  • 多语言支持
    • 支持C++，python，R语言等
  • 高度的灵活性和效率
    • 边学习边体验
  • 支持
    • 由谷歌提供支持，谷歌希望其可以成为机器学习研究和开发人员通用的语言。
• 使用 TensorFlow, 你必须明白 TensorFlow:
  • 图：TensorFlow 是一个编程系统（一个编程语言），使用图 (graph) 来表示一个计算任务或者计算单元.
    • 计算任务：实现一个加法器，那任意值的加法运算就是一个计算任务
  • 会话Session：图必须要在会话中进行执行
  • tensor（张量：数组，阶：维度）：就是numpy中的nd.array（数组），只不过从新起了一个名字而已！因此tensor一种数据类型。每个 Tensor 是一个类型化的数组. 或者是op的返回值，就是TensorFlow中的数据。tensor也可以被称为张量，那么张量的阶就是数组的维度。
  • 节点op（operation）：图表示TensorFlow的计算任务，而一个计算任务的具体实现操作就是op。一个op需要使用0个或者多个Tensor来执行计算且会产生0个会多个Tensor，简单点来说TensorFlow的API定义的函数都是op。
• 综述：
  • 图描述了tensorflow计算的过程。为了进行计算, 图必须在会话里被启动.会话将图的op分发到诸如 CPU 或 GPU 之类的设备上, 图同时提供执行op的方法. 这些方法执行后, 将产生的 tensor 返回。

Tensorflow进阶

tensorflow算子与图

TensorFlow 是用数据流图（data flow graph）做计算的，由节点（node）和边（edge）组件的有向无环图（directed acycline graph，DAG）。

节点表示计算单元，而边表示被计算单元消费或生产的数据。在 tf.Graph 的上下文中，每个 API 的调用定义了 tf.Operation（节点），每个节点可以有零个或多个输入和输出的 tf.Tensor（边）。

比如，定义 Python 变量 x：

g = tf.Graph()

with g.as_default():

    x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)

    print('name is', x.name)

    print(x)

输出：

name is Const:0

Tensor("Const:0", shape=(2, 2), dtype=float32)

这里 x 定义了一个名叫 Const 的新节点（tf.Operation）加入到从上下文集成下类的默认 tf.Graph 中。该节点返回一个名称为 Const:0 的 tf.Tensor（边）。

由于 tf.Graph 中每个节点都是唯一的，如果依据在图中存在一个名称为 Const 的节点（这是所有 tf 常量的默认名称）,TensorFlow 将在名称上添加后缀 _1、_2 等使其名称唯一。当然，也可以自定义名称。

g = tf.Graph()

with g.as_default():

    x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)

    x1 = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)

    s = tf.constant([[1, 2], [3, 4]], name='SG')

    print(x.name, x1.name, s.name)

输出：

Const:0 Const_1:0 SG:0

输出的 tf.Tensor 和其相关的 tf.Operation 名称相同，但是加上了 :ID 形式的后缀。这个 ID 是一个递增的整数，表示该运算产生了多少个输出。但是可以存在有多个输出的运算，这种情况下，:0，:1 等后缀，加到由该运算产生的 tf.Tensor 名字后。

也可以通过调用 tf.name_scope 函数定义的一个上下文，为该上下文中所有的运算添加命名范围前缀。这个前缀是用 / 分割的一个名称列表：

g = tf.Graph()

with g.as_default():

    with tf.name_scope('A'):

        x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)

        y = x

        print(x.name)

        with tf.name_scope('B'):

            x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)

    z = x + y

    print(x.name, z.name)

输出

A/Const:0

A/B/Const:0 add:0

也可以这样：

g1 = tf.Graph()

g2 = tf.Graph()

with g1.as_default():

    with tf.name_scope('A'):

        x = tf.constant(1, name='x')

        print(x)

with g2.as_default():

    with tf.name_scope('B'):

        x = tf.constant(1, name='x')

        print(x)

输出：

Tensor("A/x:0", shape=(), dtype=int32)

Tensor("B/x:0", shape=(), dtype=int32)

图放置——tf.device

tf.device 创建一个和设备相符的上下文管理器。这个函数允许使用者，请求将一个上下文创建的所有运算，放置在相同的设备上。由 tf.device 指定的设备不仅仅是物理设备。可以是远程服务器、远程设备、远程工作者即不同种类的物理设备（GPU、CPU、TPU）。需要遵照一个设备的指定规范，才能正确地告知框架来使用所需设备。一个设备指定规范有如下形式：

"/job:<JOB_NAME>/task:<TASK_INDEX>/device:<DEVICE_TYPE>:<DEVICE_INDEX>"

• <JOB_NAME>：是一个由字母和数字构成的字符串，首字母不能是数字；
• <DEVICE_TYPE>：是一个已注册过的设备类型（CPU或GPU）；
• <TASK_INDEX>：是一个非负整数，代表了名为 <JOB_NAME> 的工作中的任务编号；

with tf.device('/job:foo'):

  # ops created here have devices with /job:foo

  with tf.device('/job:bar/task:0/device:gpu:2'):

    # ops created here have the fully specified device above

  with tf.device('/device:gpu:1'):

    # ops created here have the device '/job:foo/device:gpu:1'

边

TensorFlow 的边有两种连接关系：数据依赖与控制依赖。实线边表示数据依赖，代表数据，即张量。虚线边表示控制依赖（control dependency），可以用于控制操作的运行，用来确保 happens-before 关系，这类边上没有数据流过，但源节点必须在目的节点开始前完成执行。

g = tf.Graph()

g.control_dependencies(control_inputs)

节点

graph 中的节点又称为算子，代表一个操作（tf.Operation），一般用来表示施加的数学运算，数据输入的起点及输出的终点，或者是读取/写入持久变量（persistent variable）的终点。

Tensorflow算子融合示例

• 实现一个加法运算
  • add(a,b)

定义a,b俩个tensor(张量)

import tensorflow as tf

tf.__version__  # '1.14.0'

# 定义a,b俩个tensor(张量)

a = tf.constant(1.0)

b = tf.constant(2.0)

print(a,b)

Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)

调用add的函数（op）实现两数相加

# 调用add的函数（op）实现两数相加

import tensorflow as tf

a = tf.constant(3)

b = tf.constant(4)

# 定义了一个op

sum = tf.add(a,b)

print(sum)

Tensor("Add:0", shape=(), dtype=int32)

在会话中启动图

# 在会话中启动图

import tensorflow as tf

# 定义a,b两个tensor（张量）

a = tf.constant(3)

b = tf.constant(4)

# 定义了一个op图，图对应一系列操作

sum = tf.add(a,b)

# 开启一个绘画,在绘画中执行图

with tf.Session() as sess:

    print(sess.run(sum))  # 7

获取图

• tf.get_default_graph()
• op,session,tensor的graph属性

# 在会话中启动图

import tensorflow as tf

# 定义a,b两个tensor（张量）

a = tf.constant(3)

b = tf.constant(4)

# 定义了一个op图，图对应一系列操作

sum = tf.add(a,b)

# 开启一个绘画,在绘画中执行图

with tf.Session() as sess:

    print(sess.run(sum))  # 7

    print(tf.get_default_graph()) # 返回当前的图

    print(sum.graph) # 返回当前的图

    print(a.graph) # 返回当前的图

    print(b.graph) # 返回当前的图

    print(sess.graph) # 返回当前的图

7

<tensorflow.python.framework.ops.Graph object at 0xb376c7048>

<tensorflow.python.framework.ops.Graph object at 0xb376c7048>

<tensorflow.python.framework.ops.Graph object at 0xb376c7048>

<tensorflow.python.framework.ops.Graph object at 0xb376c7048>

创建新图（创建一个单独的计算任务单元）

• tf.Graph()：新图对应的操作必须作用在上下文中！
• 上下文写法：with g.as_default()

import tensorflow as tf

g = tf.Graph() # 创建一个新图

with g.as_default():

    d = tf.constant([1,2,3])

    c = tf.constant([4,5,6])

    sum_ = tf.add(c,d)

    print(d.graph)

a = tf.constant(3)

b = tf.constant(4)

sum = tf.add(a,b)

with tf.Session() as sess: # 这里如果不采取操作，用的还是默认图

    print(sess.run(sum))

    print(sess.graph)

<tensorflow.python.framework.ops.Graph object at 0x0000021AA4A13B00>

7

<tensorflow.python.framework.ops.Graph object at 0x0000021AA49347F0>

会话Session

• 会话就是运行图的一个资源类，运行的是默认的图，当然也可以单独运行指定的图
• 会话的资源包含如下资源，会话结束后需要关闭对应的资源，因此需要在上下文资源管理器中使用会话
  • tf.Variable
  • tf.QueueBase
  • tf.ReaderBase
• TensorFlow可以分为前端系统和后端系统
  • 前端系统：定义图的结构（定义张量tensor，定义op等）
  • 后端系统：运行图

　

　　　　　

• 会话的作用：
  • 运行图的结构
  • 分配计算资源
  • 掌握资源：会话只可以运行其对应图中的资源
  • Session(graph=g)指定图

g = tf.Graph() # 创建一个新图

with g.as_default():

    d = tf.constant([1,2,3])

    c = tf.constant([4,5,6])

    sum_ = tf.add(c,d)

    print(d.graph)

a = tf.constant(3)

b = tf.constant(4)

sum = tf.add(a,b)

with tf.Session(graph=g) as sess: # 参数指定新图

    print(sess.run(sum_))

    print(sess.graph)

<tensorflow.python.framework.ops.Graph object at 0x0000021AA4BAA240>

[5 7 9]

<tensorflow.python.framework.ops.Graph object at 0x0000021AA4BAA240>

重载运算符

• session只可以运行op或者tensor，不可以运行其他类型的数据，但是如果一个tensor或者op使用某一个运算符和其他类型数据相加，则返回的为op或者tensor类型

a = tf.constant(3)

b = 4

sum = a + b

print(sum)

Tensor("add_8:0", shape=(), dtype=int32)

run方法

• s.run(fetches, feed_dict=None,graph)
  • fetches: 就是运行的op和tensor，例如run(sum)也可以run([a,b,sum])
  • feed_dict: 程序在执行的时候，不确定输入数据是什么，提前使用placeholder占个位
  • 给session提供实时运行的数据

# 应用场景：训练模型的时候，样本数量不固定，那么如何运行样本数据呢？

import tensorflow as ts

# 创建了一个op，placeholder为占位对象，现在占据了一个n行三列的位置

feature = ts.placeholder(dtype=tf.float32,shape=(None,3))# None为任意行数

with tf.Session() as s:

    print(s.run(feature,feed_dict={feature:[[1,2,3],[4,5,6],[4,5,6]]}))

[[1. 2. 3.]

 [4. 5. 6.]

 [4. 5. 6.]]

张量相关的api

• 自动生成张量：
  • tf.zeros(shape=(3,2))
  • tf.ones()
  • tf.random_normal(shape,mean,stddev)
    • mean:平均值
    • 方差
• 改变类型：
  • tf.cast(x,dtype)
• 概念：变量也是一种op，是一种特殊的张量，能够进行持久化存储（普通张量不行），变量的值为张量。
• API：tf.Variable(initial_value,name,trainable,)
  • initial_value变量接收的值（张量）
  • 在手写线性回归时讲解
• 必须进行变量的显示的初始化，返回一个初始化变量的op:
  • init_op = tf.global_variables_initializer()

arr = tf.zeros(shape = (4,5))

rand_arr = tf.random_normal(shape=(3,4),mean=2,stddev=2)

print(rand_arr)

Tensor("random_normal_5:0", shape=(3, 4), dtype=float32)

变量

import tensorflow as tf

# 变量使用步骤

# 1.实例化变量对象，给它赋一个默认的输入值

# 2.对变量进行显示化的展示

# 3.通过绘画，对显示化的变量进行展示，才能够使用定义好的变量

# 1.实例化变量对象，给它赋一个默认的输入值

a = tf.constant([1,2,3,4,5])

var = tf.Variable(initial_value=a)

# 2.对变量进行显示化的展示

# 显示的初始化

init_op = tf.global_variables_initializer()

with tf.Session() as s:

    # 3.通过绘画，对显示化的变量进行展示，才能够使用定义好的变量

    s.run(init_op)

    print(s.run(var))  

    print(a.eval())  # 相当于s.run(a)

[1 2 3 4 5]

[1 2 3 4 5]

线性回归原理回顾

• 找寻目标值和特征值之间存在的关系，求出w和b即可。
• y = (x1w1 + x2w2...+xn*wn)+b
• 损失函数(均方误差)：表示真实值和预测值之间的误差
• 使用梯度下降将损失函数的误差值最小即可
• 准备最简单的特征值和目标值
  • y = 0.8*x+1.5，然后我们需要让手写的线性回归求出w（0.8）和b（1.5）
• 建立模型
  • 随机初始化一个w和b
    • 因为模型一开始也不知道w和b应该是什么，只能随机初始化一个，然后随着梯度下降逐步迭代更新w和b
  • 然后求出预测值：y_pred = wx+b
• 求出损失函数（误差）的结果
  • 均方误差：y是真实值y'是预测值
    • ((y1-y1')^2+(y2-y2')^2+...+(yn-yn')^2)/n
• 使用梯度下降降低损失（梯度下降不需要手动实现，TensorFlow中有对应的API，只需要指定学习率即可）
• TensorFlow运算的API
  • 矩阵运算：tf.matmul(a,b)
  • 平方：tf.square(x)
  • 均值：tf.reduce_mean()
• 梯度下降API
  • 类：tf.train.GradientDescentOptimizer(learning_rate)
    • learning_rate: 需要手动指定学习率
• 线性回归是一个迭代算法，在每次梯度下降的过程中，y=wx+b中的w和b是在不停的变化的逐步在优化这两个值。因此，w和b是需要不断变化的在梯度下降的过程中！
• 结论：
  • 在TensorFlow中随机初始化的w和b，只可以用变量定义，不可以用张量，因为，变量可以自身变化，而张量不行！
  • 或者说模型的参数只可以用变量定义不可以用张量定义！！！
• tf.Variable(initial_value=None,trainable=True)
  • trainable=True表示在训练的过程中，变量的值可以跟随训练而实时变化！！！

实现流程

注意：

import tensorflow as tf

# 第一步：准备数据

# tf.random_normal 返回一个指定形状的张量

x = tf.random_normal(shape=(100,1),mean=1.5,stddev=0.75) # 特征数据

y_true = tf.matmul(x,[[0.8]])+1.5 # 标签数据 w=0.8,b=1.5

# 第二步：建立模型，随机初始化一个w和b

weight = tf.Variable(tf.random_normal(shape=(1,1),mean=1.2,stddev=0.5))

b = tf.Variable(2.5)

# 预测结果

y_pred = tf.matmul(x,weight)+b

# 第三步：损失函数就是均方误差

loss = tf.reduce_mean(tf.square(y_true - y_pred))

# 第四步.梯度下降优化损失

train_op = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

# 定义的变量进行显示初始化

init_op = tf.global_variables_initializer()

with tf.Session() as s:

    s.run(init_op) # 先运行变量的初始化操作

    print('随机初始化的w=%f,b=%f'%(weight.eval(),s.run(b)))

    for i in range(1,401):# 固定迭代的次数

        s.run(train_op)

        if i%20 == 0:

            print('第%d次优化后的w=%f,b=%f'%(i,weight.eval(),b.eval()))

随机初始化的w=0.816529,b=2.500000

第20次优化后的w=0.572955,b=1.896295

第40次优化后的w=0.680251,b=1.720152

第60次优化后的w=0.734756,b=1.615458

第80次优化后的w=0.764612,b=1.561906

第100次优化后的w=0.780714,b=1.533197

第120次优化后的w=0.789753,b=1.517574

第140次优化后的w=0.794484,b=1.509686

第160次优化后的w=0.797118,b=1.505182

第180次优化后的w=0.798350,b=1.502849

第200次优化后的w=0.799147,b=1.501556

第220次优化后的w=0.799511,b=1.500829

第240次优化后的w=0.799743,b=1.500452

第260次优化后的w=0.799859,b=1.500251

第280次优化后的w=0.799925,b=1.500136

第300次优化后的w=0.799960,b=1.500069

第320次优化后的w=0.799978,b=1.500037

第340次优化后的w=0.799988,b=1.500021

第360次优化后的w=0.799994,b=1.500011

第380次优化后的w=0.799996,b=1.500006

第400次优化后的w=0.799998,b=1.500003

模型保存与加载

代码报错（NotFindError），问题在于模型加载的路径，或者在代码头部加上tf.reset_default_graph()

• 保存的其实就是w和b
• 定义saver的op
  • saver = tf.train.Saver()
• 在会话中运行保存函数：
  • saver.save(session,'path')
    • path：表示保存模型的路径，携带模型的名称（任意名称）
• 在会话运行时加载模型：
  • if os.path.exists('./xxx/checkpoint'):
    • saver.restore(session,'path')
• 模型的加载

import os

tf.reset_default_graph()  # 如果加载保存好的模型时出现notfinderror就加上该行代码

# 第一步：准备数据

x = tf.random_normal(shape=(100,1),mean=1.5,stddev=0.75) # 特征数据

y_true = tf.matmul(x,[[0.8]])+1.5 # 标签数据 w=0.8,b=1.5

# 第二步：建立模型，随机初始化一个w和b

weight = tf.Variable(tf.random_normal(shape=(1,1),mean=1.2,stddev=0.5),name='w')

b = tf.Variable(2.5,name='b')

# 预测结果

y_pred = tf.matmul(x,weight)+b

# 第三步：损失函数就出均方误差

loss = tf.reduce_mean(tf.square(y_true-y_pred))

# 第四步.梯度下降优化损失

train_op = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

# 定义的变量进行初始化

init_op = tf.global_variables_initializer()

# 保存模型的op

saver = tf.train.Saver()

with tf.Session() as s:

    s.run(init_op) # 先运行变量的初始化操作

    if os.path.exists('./imgs/checkpoint'):# 加载模型

        print('模型已经加载读取完毕')

        saver.restore(s,'./imgs/model')

        w = s.run('w:0')

        b = s.run('b:0')

        print(w,b) # 就是从保存好的模型文件中读取出来的两个值

    else: # 保存模型

        print('随机初始化的w=%f,b=%f'%(weight.eval(),s.run(b)))

        for i in range(1,401):# 固定迭代的次数

            s.run(train_op)

            if i%20 == 0:

                print('第%d次优化后的w=%f,b=%f'%(i,weight.eval(),b.eval()))

        saver.save(s,'./imgs/model')

参考链接：

https://www.cnblogs.com/linranran/p/13435890.html

https://www.jianshu.com/p/14d9c243c3eb