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

 



 

posted @ 2021-07-10 06:20  吴建明wujianming  阅读(1231)  评论(0)  编辑  收藏  举报