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

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
• 会话就是运行图的一个资源类，运行的是默认的图，当然也可以单独运行指定的图
• 会话的资源包含如下资源，会话结束后需要关闭对应的资源，因此需要在上下文资源管理器中使用会话
o tf.Variable
o tf.QueueBase
o tf.ReaderBase
• TensorFlow可以分为前端系统和后端系统
o 前端系统：定义图的结构（定义张量tensor，定义op等）
o 后端系统：运行图
　
　　　　　
• 会话的作用：
o 运行图的结构
o 分配计算资源
o 掌握资源：会话只可以运行其对应图中的资源
o 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)
o fetches: 就是运行的op和tensor，例如run(sum)也可以run([a,b,sum])
o feed_dict: 程序在执行的时候，不确定输入数据是什么，提前使用placeholder占个位
o 给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
• 自动生成张量：
o tf.zeros(shape=(3,2))
o tf.ones()
o tf.random_normal(shape,mean,stddev)
o mean:平均值
o 方差
• 改变类型：
o tf.cast(x,dtype)
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)
变量
• 概念：变量也是一种op，是一种特殊的张量，能够进行持久化存储（普通张量不行），变量的值为张量。
• API：tf.Variable(initial_value,name,trainable,)
o initial_value变量接收的值（张量）
o 在手写线性回归时讲解
• 必须进行变量的显示的初始化，返回一个初始化变量的op:
o init_op = tf.global_variables_initializer()

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…+xnwn)+b
• 损失函数(均方误差)：表示真实值和预测值之间的误差
• 使用梯度下降将损失函数的误差值最小即可
实现流程
• 准备最简单的特征值和目标值
o y = 0.8x+1.5，然后我们需要让手写的线性回归求出w（0.8）和b（1.5）
• 建立模型
o 随机初始化一个w和b
o 因为模型一开始也不知道w和b应该是什么，只能随机初始化一个，然后随着梯度下降逐步迭代更新w和b
o 然后求出预测值：y_pred = wx+b
• 求出损失函数（误差）的结果
o 均方误差：y是真实值y’是预测值
o ((y1-y1’)^2+(y2-y2’)2+…+(yn-yn’)^2)/n
• 使用梯度下降降低损失（梯度下降不需要手动实现，TensorFlow中有对应的API，只需要指定学习率即可）
• TensorFlow运算的API
o 矩阵运算：tf.matmul(a,b)
o 平方：tf.square(x)
o 均值：tf.reduce_mean()
• 梯度下降API
o 类：tf.train.GradientDescentOptimizer(learning_rate)
o learning_rate: 需要手动指定学习率
注意：
• 线性回归是一个迭代算法，在每次梯度下降的过程中，y=wx+b中的w和b是在不停的变化的逐步在优化这两个值。因此，w和b是需要不断变化的在梯度下降的过程中！
• 结论：
o 在TensorFlow中随机初始化的w和b，只可以用变量定义，不可以用张量，因为，变量可以自身变化，而张量不行！
o 或者说模型的参数只可以用变量定义不可以用张量定义！！！
• tf.Variable(initial_value=None,trainable=True)
o 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
o saver = tf.train.Saver()
• 在会话中运行保存函数：
o saver.save(session,‘path’)
o path：表示保存模型的路径，携带模型的名称（任意名称）
• 在会话运行时加载模型：
o if os.path.exists(’./xxx/checkpoint’):
o 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

TensorFlow算子融合相关推荐

SystemML大规模机器学习，优化算子融合方案的研究
SystemML大规模机器学习,优化算子融合方案的研究摘要许多大规模机器学习(ML)系统允许通过线性代数程序指定定制的ML算法,然后自动生成有效的执行计划.在这种情况下,优化的机会融合基本算子的熔 ...
TVM图优化与算子融合
TVM图优化与算子融合计算图的定义 Computational graphs: a common way to represent programs in deep learning framewo ...
MXNet 图优化与算子融合
MXNet 图优化与算子融合Graph Optimization and Quantization based on subgraph and MKL-DNN Purpose MKL-DNN引入了两个 ...
TVM优化Deep Learning GPU算子
TVM优化Deep Learning GPU算子高效的深度学习算子是深度学习系统的核心.通常,这些算子很难优化,需要HPC专家付出巨大的努力. 端到端张量IR / DSL堆栈TVM使这一过程变得更加 ...
TensorFlow+TVM优化NMT神经机器翻译
TensorFlow+TVM优化NMT神经机器翻译背景神经机器翻译(NMT)是一种自动化的端到端方法,具有克服传统基于短语的翻译系统中的弱点的潜力.本文为全球电子商务部署NMT服务. 目前,将Tr ...
TensorFlow、PyTorch之后，“国产”AI框架还有没有机会？
出品 | AI科技大本营(ID:rgznai100) 众所周知,在机器学习框架领域,PyTorch.TensorFlow已分别成为目前学界和业界使用最广泛的两大实力玩家,而紧随其后的Keras.MXN ...
2020，国产AI开源框架“亮剑”TensorFlow、PyTorch
「AI技术生态论」人物访谈栏目是CSDN发起的百万人学AI倡议下的重要组成部分.通过对AI生态专家.创业者.行业KOL的访谈,反映其对于行业的思考.未来趋势的判断.技术的实践,以及成长的经历. 20 ...
ai算子是什么_肇观电子刷新端侧AI芯片性能记录并发布“5分钟部署”AI开发平台 - 企业资讯...
基于多年研发的CVKit™ NN IP的N1系列SoC芯片刷新了端侧AI芯片性能记录.领先的每TOPs处理帧数,实时数据流处理能力,支持高精度FP16神经网络模型直接无损部署,高性能的INT8网络支持 ...

TensorFlow算子融合

ops created here have devices with /job:foo

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

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

定义了一个op

在会话中启动图

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

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

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

在会话中启动图

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

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

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

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

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

变量使用步骤

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

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

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

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

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

显示的初始化

第一步：准备数据

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

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

预测结果

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

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

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

第一步：准备数据

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

预测结果

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

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

定义的变量进行初始化

保存模型的op

TensorFlow算子融合相关推荐

最新文章

热门文章