华为泰克人工智能实训
文章目录
TensorFlow计算模型——计算图
计算图是TensorFlow中最基本的一个概念，TensorFlow中所有的计算都会被转化为计算图上的节点。下面将详细介绍：
- TensorFlow中计算图的概念
- TensorFlow计算图的使用方法
计算图的概念
TensorFlow的名字中已经说明了它最重要的两个概念：Tensor 和 Flow。
Tensor 就是张量。张量这个概念在数学或者物理学中可以有不同的解释，但在本书中并不强调它本身的含义。在TensorFlow中，张量可以被简单地理解为多维数组。
如果说 TensorFlow 的第一个词 Tensor 表明了它的数据结构， 那么 Flow 则体现了它的计算模型。 Flow翻译成中文就是流，它直观地表达了张量之间通过计算相互转化的过程。
TensorFlow是一个通过计算图的形式来表述计算的编程系统。TensorFlow中的每一个计算都是计算图上的一个节点，而节点之间的边描述了计算之间的依赖关系，以及Tensor的流动方向。
计算图的使用
TensorFlow 程序一般可以分为两个阶段：
- 定义计算图中所有的计算
- 执行计算
下面一段代码是定义计算阶段的样例：
import tensorflow as tf
a = tf.constant([1.0, 2.0], name = "a")
b = tf.constant([2.0, 3.0], name = "b")
result = a + b
在Python中一般会采用 import tensorflow as tf 的形式来载入TensorFlow，这样可以使用 tf 来代替 tensorflow 作为模块名称，这样会使得整个程序更加简洁。这是Python中很常用的技巧。
在上述过程中，TensorFlow会自动将定义的计算转化为计算图上的节点。
在TensorFlow程序中，系统会自动维护一个默认的计算图，通过 tf.get_default_graph() 函数可以获取当前默认的计算图。以下代码示意了如何获取默认计算图以及如何查看一个运算所属的计算图：
print(a.graph is tf.get_default_graph())
通过 a.graph 可以查看张量a所属的计算图。因为没有特意指定，所以这个计算图应该等于当前默认的计算图，故上述操作的输出值应当为 True。
除了使用默认的计算图，TensorFlow 还支持通过 tf.Graph() 函数来生成新的计算图。不同计算图上的张量和运算都不会共享，也就是各个计算图之间是相互独立的。
实验：计算图操作
关于本实验
本实验通过几个实例操作，了解计算图的相关操作。
实验目的
理解图的相关操作。
实验介绍
本例演示了如何建立图，并设置为默认图，使用get_default_graph()方法获取当前默认图，验证默认图的设置生效。
演示获取图中的相关内容的操作。
实验步骤
- 创建
graph.py - 打开文件，输入脚本内容
- 保存文件并退出
- 运行
python graph.py
实验过程
导入模块
import numpy as np
import tensorflow as tf
创建图
# 1 crteate the graph
c = tf.constant(0.0)
g = tf.Graph()
with g.as_default():
c1 = tf.constant(0.0)
print(c1.graph)
print("g:\n", g)
print("c.graph:\n", c.graph)
g2 = tf.get_default_graph()
print("g2:\n", g2)
tf.reset_default_graph()
g3 = tf.get_default_graph()
print("g3:\n", g3)
print("-" * 20, "1", "-" * 20, "\n")
获取tensor
# 2.get tensor
print(c1.name)
t = g.get_tensor_by_name(name="Const:0")
print(t)
print(c.name)
t1 = g2.get_tensor_by_name(name="Const:0")
print(t1)
print("-" * 20, "2", "-" * 20, "\n")
获取op
# 3.get op
a = tf.constant([[1.0, 2.0]])
b = tf.constant([[1.0], [3.0]])
tensor1 = tf.matmul(a, b, name='exampleop')
print(tensor1.name, tensor1)
test = g3.get_tensor_by_name("exampleop:0")
print("test:\n", test)
print("name:\n", tensor1.op.name)
testop = g3.get_operation_by_name("exampleop")
print("testop:\n", testop)
with tf.Session() as sess:
test = sess.run(test)
print("test1:\n", test)
test = tf.get_default_graph().get_tensor_by_name("exampleop:0")
print("test2:\n", test)
print("-" * 20, "3", "-" * 20, "\n")
获取所有列表
# 4.Get all lists
# Return to the list of operation nodes in the figure
tt2 = g.get_operations()
print(tt2)
print("-" * 20, "4", "-" * 20, "\n")
获取对象
# 5.返回一个图中与obj相关联的对象，为一个操作节点或者tensor数据
tt3 = g.as_graph_element(c1)
print(tt3)
print("-" * 20, "5", "-" * 20, "\n")
实验结果
<tensorflow.python.framework.ops.Graph object at 0x182d97f390>
g:
<tensorflow.python.framework.ops.Graph object at 0x182d97f390>
c.graph:
<tensorflow.python.framework.ops.Graph object at 0x1100e25f8>
g2:
<tensorflow.python.framework.ops.Graph object at 0x1100e25f8>
g3:
<tensorflow.python.framework.ops.Graph object at 0x182d97f4a8>
-------------------- 1 --------------------
Const:0
Tensor("Const:0", shape=(), dtype=float32)
Const:0
Tensor("Const:0", shape=(), dtype=float32)
-------------------- 2 --------------------
exampleop:0 Tensor("exampleop:0", shape=(1, 1), dtype=float32)
test:
Tensor("exampleop:0", shape=(1, 1), dtype=float32)
name:
exampleop
testop:
name: "exampleop"
op: "MatMul"
input: "Const"
input: "Const_1"
attr {
key: "T"
value {
type: DT_FLOAT
}
}
attr {
key: "transpose_a"
value {
b: false
}
}
attr {
key: "transpose_b"
value {
b: false
}
}
2018-07-25 09:19:35.170304: I tensorflow/core/platform/cpu_feature_guard.cc:140] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
test1:
[[7.]]
test2:
Tensor("exampleop:0", shape=(1, 1), dtype=float32)
-------------------- 3 --------------------
[<tf.Operation 'Const' type=Const>]
-------------------- 4 --------------------
Tensor("Const:0", shape=(), dtype=float32)
-------------------- 5 --------------------
实例描述
使用tf.reset_default_graph函数必须保证当前图的资源已经完全释放，否则会报错。
可以通过名字得到对应的元素。
get_tensor_by_name可以获取到图里的张量。
利用get_operation_by_name获取节点操作。
利用get_operations函数获取元素列表。
根据对象获取元素即使用tf.Graph.as_graph_element()，传入一个对象，返回一个张量或者OP。函数as_graph_element获得了c1的真实张量对象，并赋给了变量tt3。
本实验介绍了图比较简单的操作。
TensorFlow数据模型——张量
张量的概念
从 TensorFlow 的名字就可以看出张量(tensor)是一个很重要的概念。在 TensorFlow 程序中，所有的数据都通过张量的形式来表示。
从功能的角度上看，张量可以被简单理解为多维数组。其中零阶张量表示标量(scalar)，也就是一个数；第一阶张量为 向量(vector)，也就是一个一维数组；第 n 阶张量可以理解为一个 n 维数组。但张量在 TensorFlow 中的实现并不是直接采用数组的形式，它只是对TensorFlow中运算结果的引用。在张量中并没有真正保存数字，它保存的是如何得到这些数字的计算过程。
import tensorflow as tf
# tf.constant是一个计算，这个计算的结果为一个张量，保存在变量a中。
a = tf.constant([l.O, 2.0], name="a")
b = tf. constant ([2. 0, 3. OJ, name="b")
result = tf.add(a, b, name="add")
print(result)
输出：
Tensor("add:0", shape=(2,), dtype=float32)
TensorFlow 中的张量和 Numpy 中的数组不同，TensorFlow 计算的结果不是一个具体的数字，而是一个张量的结构。从上面代码的运行结果可以看出，一个张量中主要保存了三个属性：名字(name)、维度(shape)和类型(type)。
张量的第一个属性名字不仅是一个张量的唯一标识符，它同样也给出了这个张量是如何计算出来的。在3.1.2 小节中介绍了TensorFlow的计算都可以通过计算图的模型来建立，而计算图上的每 个节点代表了 个计算， 计算的结果就保存在张量之中。 所以张量和计算图上节点所代表的计算结果是对应的。 这样张量的命名就可以通过"node:src_output"的形式来给出。 其中 node为节点的名称， src_output表示当前张量来自节点的第几个输出。
张量的第二个属性是张量的维度(shape)。这个属性描述了一个张量的维度信息。比如上面样例中shape=(2,)说明了张量 result 是一个一维数组，这个数组的长度为2。维度是张量一个很重要的属性，围绕张量的维度TensorFlow也给出了很多有用的运算，在这里先不一一列举，在后面的章节中将使用到部分运算。
张量的第三个属性是类型(type)，每一个张量会有一个唯一的类型。TensorFlow会对参与运算的所有张量进行类型的检查，当发现类型不匹配时会报错。比如运行下面这段程序时就会得到类型不匹配的错误
import tensorflow as tf
a = tf.constant([1, 2], name="a")
b = tf.constant([2.0, 3.0], name="b")
result= a + b
这段程序和上面的样例基本一模一样，唯一不同的是把其中一个加数的小数点去掉了。这会使得加数a的类型为整数而加数b的类型为实数，这样程序会报类型不匹配的错误：
ValueError: Tensor conversion requested dtype int32 for Tensor with dtype float32: 'Tensor("b:0, shape=(2,), dtype=float32)'
张量的使用
和TensorFlow的计算模型相比，TensorFlow的数据模型相对比较简单，张量的使用可以总结为两大类：
- 对中间计算结果的引用
当一个计算包含很多中间结果时，使用张量可以大大提高代码的可读性。以下为使用张量和不使用张量记录中间结果来完成向量相加的功能代码的对比：
import tensorflow as tf
# 使用张量记录中间结果
a = tf.constant([1.0, 2.0], name = "a")
b = tf.constant([2.0, 3.0], name = "b")
result = a + b
# 不使用张量记录中间结果
result = tf.constant([1.0, 2.0], name = "a") + tf.constant([2.0, 3.0], name = "b")
- 当计算图构造完成后，张量可以用来获取计算结果
虽然张量本身没有存储具体的数字，但是通过后面介绍的会话，就可以得到这些具体的数字，比如在上面的代码中，可以使用下面的语句来得到计算结果：
tf.Session().run(result)
实验：变量的定义
关于本实验
本实验通过使用tf.Variable创建变量（节点），学习变量的用法。
实验目的
理解tf.Variable和get_variable，并使用get_variable获取变量。
理解tf.Variable和get_variable的区别。
实验介绍
通过实验了解tf.Variable和get_variable的用法，并了解两者的区别。
实验步骤
- 创建**
get_variable.py** - 打开文件，输入脚本内容
- 保存文件并退出
- 运行**
python get_variable.py**命令，测试脚本
实验过程
导入模块
import tensorflow as tf
重置计算图
tf.reset_default_graph()
定义variable变量
var1 = tf.Variable(10.0, name="varname")
var2 = tf.Variable(11.0, name="varname")
var3 = tf.Variable(12.0)
var4 = tf.Variable(13.0)
定义get_variable变量
with tf.variable_scope("test1"):
var5 = tf.get_variable("varname",
shape=[2],
dtype=tf.float32)
with tf.variable_scope("test2"):
var6 = tf.get_variable("varname",
shape=[2],
dtype=tf.float32)
输出变量
print("var1:",var1.name) #print variable 1
print("var2:",var2.name) #print variable 2
print("var3:",var3.name) #print variable 3
print("var4:",var4.name) #print variable 4
print("var5:",var5.name) #print get_variable 1
print("var6:",var6.name) #print get_variable 2
实验结果
输出结果：
var1: varname:0
var2: varname_1:0
var3: Variable:0
var4: Variable_1:0
var5: test1/varname:0
var6: test2/varname:0
TensorFlow运行模型——会话
前面的两节介绍了 TensorFlow 是如何组织数据和运算的。本节将介绍如何使用 TensorFlow 中的会话(session)来执行定义好的运算 。会话拥有并管理TensorFlow 程序运行时的所有资源。当所有计算完成之后需要关闭会话来帮助系统回收资源，否则就可能出现资源泄涌的问题。TensorFlow 中使用会话的模式一般有两种，第一种模式需要明确调用会话生成函数和关闭会话函数，这种模式的代码流程如下。
#创建一个会话。
sess=tf.Session()
# 使用这个创建好的会话来得到关心的运算的结果。比如可以调用sess.run(result)
# 来得到张量 result 的取值。
sess.run(...)
# 关闭会话使得本次运行中使用到的资源可以被释放。
sess.close()
使用这种模式时 ，在所有计算完成之后，需要明确调用 Session.close 函数来关闭会话并释放资源。然而，当程序因为异常而退出时，关闭会话的函数可能就不会被执行从而导致资源泄漏。为了解决异常退出时资源释放的问题，TensorFlow 可以通过 Python 的上下文管理器来使用会话。以下代码展示了如何使用这种模式。
# 创建—个会话，并通过Pyt hon 中的上下文管理器来管理这个会话。
with tf.Session() as sess:
#使用这创建好的会话来计算关心的结果。
sess.run(...)
# 不需要再调用“Session.close()”函数来关闭会话，
# 当上下文退出时会话关闭和资源释放也自动完成了。
通过 Python 上下文管理器的机制，只要将所有的计算放在"with"的内部就可以。当上下文管理器退出时候会自动释放所有资源。这样既解决了因为异常退出时资源释放的问题，同时也解决了忘记调用 Session.close 函数而产生的资源泄漏。
TensorFlow 会自动生成一个默认的计算图，如果没有特殊指定，运算会自动加入这个计算图中。TensoFlow中的会话也有类似的机制，但 TensorFlow 不会自动生成默认的会话，而是需要手动指定。当默认的会话被指定之后可以通过 tf.Tensor.eval 函数来计算一个张量的取值。以下代码展示了通过设定默认会话计算张量的取值。
sess = tf.Session()
with sess.as_default():
print(result.eval())
以下代码也可以完成相同的功能。
sess = tf.Session()
# 下面的两个命令有相同的功能。
print(sess.run(result))
print(result.eval(session=sess))
在交互式环境下（比如 Python 脚本或者 Jupyter 的编辑器下，）通过设置默认会话的方式来获取张量的取值更加方便。所以 TensorFlow 提供了一种在交互式环境下直接构建默认会话的函数。这个函数就是 tf.InteractiveSession。使用这个函数会自动将生成的会话注册为默认会话。以下代码展示了 tf.InteractiveSession 函数的用法。
sess = tf.InteractiveSession()
print(result.eval())
sess.close()
通过 tf.InteractiveSession 函数可以省去将产生的会话注册为默认会话的过程。无论使用哪种方法都可以通过 ConfigProtoProtocolBuffer 来配置需要生成的会话。下面给出了通过 ConfigProto 配置会话的方法：
config = tf.ConfigProto(allow_soft_placement = True, log_device_placement = True)
sess1 = tf.InteractiveSession(config=config)
sess2 = tf.Session(config=config)
通过 ConfigProto 可以配置类似并行的线程数、GPU 分配策略、运算超时时间等参数。在这些参数中，最常使用的有两个。第一个是 allow_soft_placement,这是一个布尔型的参数，当它为 True 的时候，在以下任意一个条件成立的时候，GPU 上的运算可以放到 CPU 上进行：
- 运算无法在 GPU 上执行。
- 没有 GPU 资源（比如运算被指定在第二个 GPU 上运行，但是机器只有一个 GPU)。
- 运算输入包含对 CPU 计算结果的引用。
实验：使用会话
关于本实验
本实验通过使用with语法开启session，帮助了解session的用法。
实验目的
理解session。
理解如何利用with建立session。
实验介绍
with session是最常见的session开启方法，沿用了Python中with的语法，也就是Python的上下文管理，当程序结束后会自动关闭session而不需要写close。
实验步骤
- 创建
withsession.py - 打开文件，输入脚本内容
- 保存文件并退出
- 运行
python withsession.py命令，测试脚本
实验过程
导入模块
import tensorflow as tf
定义TensorFlow节点
a = tf.constant(3) #定义常量3
b = tf.constant(4) #定义常量4
建立Session
with tf.Session() as sess: #建立session
print ("相加: %i" % sess.run(a+b)) #计算输出两个变量相加的值
print( "相乘: %i" % sess.run(a*b)) #计算输出两个变量相乘的值
实验结果
输出结果：
相加: 7
相乘: 12
实例描述
使用 with session 方法建立 session，并在session中计算两个变量（3 和 4）的相加与相乘值。
扫一扫
4931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
