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 是一个编程系统（一个编程语言），使用图 (graph) 来表示一个计算任务或者计算单元.
- 综述：
- 图描述了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()
withg.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()
withg.as_default():
withtf.name_scope('A'):
x=tf.constant([[1,2],[3,4]],dtype=tf.float32)
y=x
print(x.name)
withtf.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:0add:0
也可以这样：
g1=tf.Graph()
g2=tf.Graph()
withg1.as_default():
withtf.name_scope('A'):
x=tf.constant(1,name='x')
print(x)
withg2.as_default():
withtf.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>的工作中的任务编号；
withtf.device('/job:foo'):
# ops created here have devices with /job:foo
withtf.device('/job:bar/task:0/device:gpu:2'):
# ops created here have the fully specified device above
withtf.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
- 随机初始化一个w和b
- 求出损失函数（误差）的结果
- 均方误差：y是真实值y'是预测值
- ((y1-y1')^2+(y2-y2')^2+...+(yn-yn')^2)/n
- 均方误差：y是真实值y'是预测值
- 使用梯度下降降低损失（梯度下降不需要手动实现，TensorFlow中有对应的API，只需要指定学习率即可）
- TensorFlow运算的API
- 矩阵运算：tf.matmul(a,b)
- 平方：tf.square(x)
- 均值：tf.reduce_mean()
- 梯度下降API
- 类：tf.train.GradientDescentOptimizer(learning_rate)
- learning_rate: 需要手动指定学习率
- 类：tf.train.GradientDescentOptimizer(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：表示保存模型的路径，携带模型的名称（任意名称）
- saver.save(session,'path')
- 在会话运行时加载模型：
- if os.path.exists('./xxx/checkpoint'):
- saver.restore(session,'path')
- if os.path.exists('./xxx/checkpoint'):
- 模型的加载
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
人工智能芯片与自动驾驶
