TensorFlow 学习（二）：图、会话

最新推荐文章于 2020-09-02 19:27:50 发布

北海北_CrazyZheng

最新推荐文章于 2020-09-02 19:27:50 发布

阅读量517

点赞数

分类专栏： python-第三方库-tensorflow

本文链接：https://blog.csdn.net/lusics/article/details/87879763

版权

python-第三方库-tensorflow 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

重点：

图

会话

变量

张量

fetch,feed

-------------------------------

tensorflow国内外官网：

https://tensorflow.org/

https://tensorflow.google.cn/

实际上就是numerical computation using data flow graphs

tensorflow可以在github里下载:https://github.com/tensorflow/tensorflow

理解：

TensorFlow™ 是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。Tensor（张量）意味着N维数组，Flow（流）意味

着基于数据流图的计算。Tensorflow运行过程就是张量从图的一端流动到另一端的计算过程。其中节点（Nodes）在图中表示数学操作，线（Edges）则表示在节点间相互联系的多维数据数组，即张量（Tensor）

特性:

高度的灵活性：只要能够将计算表示成为一个数据流图，那么就可以使用TensorFlow。

可移植性：TensorFlow支持CPU和GPU的运算，并且可以运行在台式机、服务器、手机移动端设备等等。

自动求微分：TensorFlow内部实现了自动对于各种给定目标函数求导的方式。

多种语言支持：Python、C++

性能高度优化：

官网的一个模型，非常好：

http://playground.tensorflow.org/#activation=tanh&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&regularizationRate=0&noise=0&networkShape=4,2&seed=0.58829&showTestData=false&discretize=false&percTrainData=50&x=true&y=true&xTimesY=false

安装说明;

要求：Python必须是64位

根据TensorFlow的计算方式，TensorFlow的安装分为CPU版本和GPU版本

对于Python3.5或者Python3.6，可以使用pip install tensorflow（安装CPU版本）和pip install tensorflow-gpu（安装GPU版本）

对于Python2.7，Windows操作系统只能通过源码编译来安装TensorFlow

备注：TensorFlow-GPU要求机器的显卡必须是NVidia的显卡。

备注：授课TensorFlow版本选择1.4.0

CPU版本：只支持程序在CPU上计算/运算，默认运行就是CPU上运行

卸载：

pip uninstall tensorflow

pip uninstall tensorflow-tensorboard

安装：

pip install tensorflow==1.4.0

GPU版本：支持GPU、CPU上的计算/运算，默认运行在GPU上，但是可以明确指定在CPU上运行（因为GPU的运行速度比CPU要快，所以会仅可能的将程序运行在GPU上）

卸载：

pip uninstall tensorflow-gpu tensorflow-tensorboard

安装：

pip install tensorflow-gpu==1.4.0

备注：必须安装CUDA和cuDNN; 必须要求机器有NVIDIA显卡

各部分理解：

图（Graph）：图描述了计算的过程，TensorFlow使用图来表示计算任务。

张量（Tensor）：TensorFlow使用tensor表示数据。每个Tensor是一个类型化的多维数组。

操作（op）：图中的节点被称为op（opearation），一个op获得/输入0个或多个Tensor，执行计算，产生0个或多个Tensor。

会话（Session）：图必须在称之为“会话”的上下文中执行。会话将图的op分发到诸如CPU或GPU之类的设备上执行。

变量（Variable）：运行过程中可以被改变，用于维护状态。

TensorFlow的边即有两种连接关系：数据依赖、控制依赖

实线边表示数据依赖，代表数据，即张量。任意维度的数据统称为张量。在机器学习算法中，张量在数据流图中从前往后流动一遍就完成一次前向传播，而残差从后向前流动一遍就完成一次反向传播。

虚线边表示控制依赖，可以用于控制操作的运行，这被用来确保happensbefore关系，这类边上没有数据流过，但源节点必须在目的节点开始执行前完成。

节点又称为算子，它代表一个操作，一般用来表示施加的数字运算，也可以表示数据输入的起点以及输出的重点，或者是读取/写出持久化变量的终点。

使用图(graph)来表示计算任务；

在会话(session)的上下文中执行图；

使用tensor表示数据；

通过变量(Variable)来维护状态；

使用feed和fetch可以为任意的操作(Operation/op)赋值或者从其中获取数据。(feed是赋值，fetch是取值)

TensorFlow的程序一般分为两个阶段：构建阶段和执行阶段；

构建阶段：op的执行步骤被描述称为一个图，然后使用TensorFlow提供的API构建这个图。

执行阶段：将构建好的执行图(Operation Graph)在给定的会话中执行，并得到执行结果。

TensorFlow编程的重点是根据业务需求，使用TensorFlow的API将业务转换为执行图（有向无环图）；图中的节点是Tensor，节点之间的连线是节点之间的操作，连线前的节点可以认为是操作的输入，连线后的节点可以认为操作的输出；根据节点的特性（是否有输入输出），可以将节点分为源节点、中间节点和最终的结果节点。图构建的第一步就是创建源op(source op); 源op不需要任何的输入。op构造器的返回值代表被构造出的op的输出，这些返回值可以传递给其它op构造器作为输入或者直接获取结果。

TensorFlow库中有一个默认图(default graph)，op构造器可以直接为其添加节点，一般情况下，使用默认的Graph即可完成程序代码的实现。不过TensorFlow也支持通过Graph类管理多个图。

import tensorflow as tf

a=tf.constant(4.0)

print("a in {}".format(a.graph is tf.get_default_graph()))#true

g=tf.Graph()

with g.as_default():

    b=tf.constant(3.0)

    print("b in {}".format(b.graph is g))#true

    print("b in {}".format(b.graph is tf.get_default_graph()))#true

print("b in {}".format(b.graph is tf.get_default_graph()))#false

print("a in {}".format(a.graph is tf.get_default_graph()))#true

'''

在with内，g是默认图，在with外不是

'''

with tf.Graph().as_default() as g2:

    e=tf.constant(6.0)

#e=tf.add(b,e)#不能合并多个图

实际上构建多个图没什么用处

当执行图构建完成后，才能给启动图，进入到执行阶段；启动图的第一步就是创

建一个Session对象，如果无任何参数的情况下，会话构造器将启动默认图。

sess=tf.Session()

#等同于

#sess=tf.Session(graph=tf.get_default_graph())

#默认执行默认图

result=sess.run()

#返回一个list集合

result=sess.run(fetches=[c,r])

#或者

result=c.eval()

sess.close()

两种创建sess的方式，一般选with

tf.Session在构建会话的时候，如果不给定任何参数，那么构建出来Session对应的内部的Graph其实就是默认Graph，不过我们可以通过参数给定具体对应的是那一个Graph以及当前Session对应的配合参数。Session的构造主要有三个参数，作用如下：

target：给定连接的url，只有当分布式运行的时候需要给定(后面分布式运行讲)；

graph：给定当前Session对应的图，默认为TensorFlow中的默认图；

config：给定当前Session的相关参数，参数详见：

https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/protobuf/config.proto

中的[ConfigProto]

Tensor张量：

TensorFlow使用Tensor数据结构来代表所有数据，计算图中，操作间传递的数据都是Tensor。Tensor可以看作是一个n维的数组或者列表，一个Tensor主要由一个静态数据类型和动态类型的维数(Rank、Shape)组成。Tensor可以在图中的节点之间流通。

TensorFlow变量：

变量(Variables)是维护图执行过程中的状态信息。在训练模型过程中，可以通过变量来存储和更新参数。变量包含张量(Tensor)存放于内存的缓存区。建模的时候变量必须被明确的初始化，模型训练后变量必须被存储到磁盘。这些变量的值可以在之后的模型训练和分析中被加载。在构建变量的时候，必须将一个张量或者可以转化为张量的Python对象作为初始值传入构造函数Variable中。

特别注意：变量的全局初始化(tf.initialize_all_variables())是并行执行的，如果存在变量之间的依赖关系的时候，再进行初始化的时候要特别注意。(1.4版本之后该问题就不存在了)

Fetch机制

Feed机制

Tensorflow还提供了填充机制(feed)，可以在构建图时使用placeholder类型的API临时替代任意操作的张量(占位符)，在调用Session对象的run()方法去执行图时，使用填充数据作为调用的参数，调用结束后，填充数据就消失了。feed使用一个tensor值临时替换一个操作的输出结果，在获取数据的时候必须给定对应的feed数据作为参数。feed只有在调用它的方法内有效，方法结束，feed就消失了。

feed可以使用placeholder类型的API创建占位符，常见API：tf.placeholder、tf.placeholder_with_default

例程：

# 1. 实现一个累加器，并且每一步均输出累加器的结果值

import tensorflow as tf

x=tf.Variable(0,dtype=tf.int32,name="x_1")#变量定义

assign_op=tf.assign(x,x+1)#变量更新

或者：x=tf.add(x,tf.constant(1,dtype=tf.int32))

x_init_op=tf.global_variables_initializer()#变量初始化

with tf.Session(config=tf.ConfigProto(

log_device_placement = True,#是否打印设备分配日志

allow_soft_placement = True #如果你指定的设备不存在，允许TF自动分配设备

)) as sess:

sess.run(x_init_op)#初始化变量

for i in range(5):

sess.run(assign_op)

print(sess.run(x))#显示中间结果

## 2. 编写一段代码，实现动态的更新变量的维度数目

import tensorflow as tf

x=tf.Variable(initial_value=[],dtype=tf.float32,trainable=True,validate_shape=False)

concat=tf.concat([x,[0.0,0.0]],axis=0)

assign_op=tf.assign(x,concat,validate_shape=False)

x_init_op=tf.global_variables_initializer()

with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:

sess.run(x_init_op)

for i in range(5):

sess.run(assign_op)

print(sess.run(x))

# 3、实现一个求解阶乘的代码

import tensorflow as tf

sum=tf.Variable(1,dtype=tf.int32)

i=tf.placeholder(dtype=tf.int32)

sum_r=sum*i

assign_op=tf.assign(sum,sum_r)

x_init_op=tf.global_variables_initializer()

with tf.Session(config=tf.ConfigProto(

log_device_placement=True, allow_soft_placement=True)) as sess:

sess.run(x_init_op)

for j in range(1,6):

result=sess.run(assign_op,feed_dict={i:j})#feed_dict的作用是给使用placeholder创建出来的tensor赋值

print(result)

import tensorflow as tf

sum=tf.Variable(1,dtype=tf.int32)

i=tf.placeholder(dtype=tf.int32)

sum_r=sum*i

assign_op=tf.assign(sum,sum_r)

with tf.control_dependencies([assign_op]):#执行sum_rr，自动先执行assign_op，控制以来，要想使用sum_rr的值，先利用assign_op对其进行更新

sum_rr = tf.Print(sum, data=[sum, sum.read_value()], message='sum:')

x_init_op=tf.global_variables_initializer()

with tf.Session(config=tf.ConfigProto(log_device_placement=True, allow_soft_placement=True)) as sess:

sess.run(x_init_op)

for j in range(1,6):

result=sess.run(sum_rr,feed_dict={i:j})

#print(result)

with tf.control_dependencies([assign_op]):使用：

with g.control_dependencies([a, b]):

# Ops constructed here run after `a` and `b`.

with g.control_dependencies(None):

# Ops constructed here run normally, not waiting for either `a` or `b`

---------------------

注意：

控制依赖只对那些在上下文环境中建立的操作有效，仅仅在context中使用一个操作或张量是没用的

# WRONG

def my_func(pred, tensor):

t = tf.matmul(tensor, tensor)

with tf.control_dependencies([pred]):

# The matmul op is created outside the context, so no control

# dependency will be added.

return t

# RIGHT

def my_func(pred, tensor):

with tf.control_dependencies([pred]):

# The matmul op is created in the context, so a control dependency

# will be added.

return tf.matmul(tensor, tensor)

例子：

在训练模型时我们每步训练可能要执行两种操作，op a, b 这时我们就可以使用如下代码：

with tf.control_dependencies([a, b]):

c= tf.no_op(name='train')#tf.no_op；什么也不做

sess.run(c)

在这样简单的要求下，可以将上面代码替换为：

c= tf.group([a, b])

sess.run(c)

https://blog.csdn.net/u012436149/article/details/72084744

tf.Print()使用

Print(

input_,

data,

message=None,

first_n=None,

summarize=None,

name=None

)

input_：通过这个操作的张量。
data：计算 op 时要打印的张量列表。
message：一个字符串，错误消息的前缀。
first_n：只记录 first_n 次数。负数日志，这是默认的。
summarize：只打印每个张量的许多条目。如果没有，则每个输入张量最多打印3个元素。
name：操作的名称（可选）。

感觉教程啰里啰唆的，接下来就直接看书面讲解，https://blog.csdn.net/xierhacker/article/category/6511974

编程思想

TensorFlow 使用图来表示计算任务. 图中的节点被称之为 op (operation 的缩写). 一个 op获得 0 个或多个 Tensor , 执行计算, 产生 0 个或多个 Tensor . 每个 Tensor 是一个类型化的多维数组.tensor也是tensorflow中的核心数据类型。

一个 TensorFlow 图（graph）描述了计算的过程. 为了进行计算, 图必须在会话（session）里被启动. 会话将图的op分发到诸如 CPU 或 GPU 之类的设备上, 同时提供执行 op 的方法. 这些方法执行后, 将产生的 tensor 返回.

TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段.

在构建阶段, op 的执行步骤被描述成一个图.
在执行阶段, 使用会话执行执行图中的op.例如,通常在构建阶段创建一个图来表示和训练神经网络,然后在执行阶段反复执行图中的训练 op.

举例

import tensorflow as tf

#define the graph
info_op=tf.constant("hello,world")
a=tf.constant(10)
b=tf.constant(20)
add_op=tf.add(a,b)

#run graph in session
with tf.Session() as session:
print(session.run(info_op))
print(session.run(add_op))

tensorflow API

https://www.tensorflow.org/api_docs/python/

with tf.device('/gpu:0'): 指定运行位置

一般来说电脑只有gpu0和cpu0。

使用gpu必须有以下设置：

with tf.Session(allow_soft_placement=True) as sess:

如果GPU没法运行，自动移到CPU上运行。

北海北_CrazyZheng

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
TensorFlow 学习（二）：图、会话

重点：图会话变量张量fetch,feed-------------------------------tensorflow国内外官网：https://tensorflow.org/https://tensorflow.google.cn/实际上就是numerical computation using data flow graphstensorflow...
复制链接

扫一扫