计算机视觉—TensorFlow入门(5)

3,731 阅读6分钟

一、基本使用

使用 TensorFlow, 你必须明白 TensorFlow:

1、使用图 (Graph) 来表示计算任务.
2、在被称之为 会话 (Session) 的上下文 (Context) 中执行图.
3、使用 张量(Tensor) 表示数据.
4、通过 变量 (Variable) 维护状态.
5、使用 feed 和 fetch 可以为任意的操作(Arbitrary operation) 赋值或者从其中获取数据.

1、计算图(Graph)

计算图是计算代数中的一个基础处理方法,我们可以通过一个有向图来表示一个给定的数学表达式,并可以根据图的特点快速方便对表达式中的变量进行求导。而神经网络的本质就是一个多层复合函数, 因此也可以通过一个图来表示其表达式。

本部分主要总结计算图的实现,在计算图这个有向图中,每个节点op (operation 的缩写)代表着一种特定的运算例如求和,乘积,向量乘积,平方等等… 例如求和表达式f(x,y)=x+y使用有向图表示为:

表达式f(x,y,z)=z(x+y)使用有向图表示为:

但是在TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.

例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.

2、构建图

构建图的第一步, 是创建源 op (source op). 源 op 不需要任何输入, 例如 常量 (Constant). 源 op 的输出被传递给其它 op 做运算.

Python 库中, op 构造器的返回值代表被构造出的 op 的输出, 这些返回值可以传递给其它 op 构造器作为输入.

TensorFlow Python 库有一个默认图 (default graph), op 构造器可以为其增加节点. 这个默认图对 许多程序来说已经足够用了.

Graph 类 API链接:http://www.tensorfly.cn/tfdoc/api_docs/python/framework.html#Graph

import tensorflow as tf

# 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
# 加到默认图中.
#
# 构造器的返回值代表该常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])

# 创建另外一个常量 op, 产生一个 2x1 矩阵.
matrix2 = tf.constant([[2.],[2.]])

# 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
# 返回值 'product' 代表矩阵乘法的结果.
product = tf.matmul(matrix1, matrix2)

默认图现在有三个节点, 两个 constant() op, 和一个matmul() op. 为了真正进行矩阵相乘运算, 并得到矩阵乘法的 结果, 你必须在会话里启动这个图.

3、在一个会话中启动图

构造阶段完成后, 才能启动图. 启动图的第一步是创建一个 Session 对象, 如果无任何创建参数, 会话构造器将启动默认图. Session 类 API链接:http://www.tensorfly.cn/tfdoc/api_docs/python/client.html#session-management

# 启动默认图.
sess = tf.Session()

# 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数. 
# 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
# 矩阵乘法 op 的输出.
#
# 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
# 
# 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
#
# 返回值 'result' 是一个 numpy `ndarray` 对象.
result = sess.run(product)
print (result)
# ==> [[ 12.]]

# 任务完成, 关闭会话.
sess.close()

结果:

[[12.]]

Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 "with" 代码块 来自动完成关闭动作.

with tf.Session() as sess:
  result = sess.run([product])
  print (result)

结果:

[array([[12.]], dtype=float32)]

二、常量和变量

(1)常量

data1 = tf.constant(2,dtype = tf.int32)
print(data1)
sess = tf.Session()
print(sess.run(data1))
# Tensor 是张量, shape 是维度, dtype 是数据类型 ,tf.Variable 是变量

结果:

Tensor("Const_6:0", shape=(), dtype=int32)
2

(2)变量

data2 = tf.Variable(10,name='var')
print(data2)
sess = tf.Session()
init = tf.global_variables_initializer()
# 如果不初始化会报错
sess.run(init)
print(sess.run(data2))

结果:

<tf.Variable 'var_6:0' shape=() dtype=int32_ref>
10

三、常量变量四则运算

1、常量四则运算

data3 = tf.constant(6)
data4 = tf.constant(2)
dataAdd = tf.add(data3,data4) # 加
dataSub = tf.subtract(data3,data4) # 减
dataMul = tf.multiply(data3,data4) # 乘
dataDiv = tf.divide(data3,data4) # 除
with tf.Session() as sess:
    print (sess.run(dataAdd))
    print (sess.run(dataSub))
    print (sess.run(dataMul))
    print (sess.run(dataDiv))
print('End!')

结果:

8
4
12
3.0
End!

2、变量四则运算

data5 = tf.constant(6)
data6 = tf.Variable(4)
dataAdd = tf.add(data5,data6) # 加
dataCopy = tf.assign(data6,dataAdd) 
# 把dataAdd的运算结果,赋值到data6
dataSub = tf.subtract(data5,data6) # 减
dataMul = tf.multiply(data5,data6) # 乘
dataDiv = tf.divide(data5,data6) # 除

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)
    print ('加:',sess.run(dataAdd))
    print ('减:',sess.run(dataSub))
    print ('乘:',sess.run(dataMul))
    print ('除:',sess.run(dataDiv))
    print ('dataCopy :',sess.run(dataCopy)) 
    # dataAdd  = 10 
    print ('dataCopy.eval() :',dataCopy.eval()) 
    # eval(expression[, globals[, locals]]) , 用来执行一个字符串表达式,并返回表达式的值
    # dataAdd + data5 = 10 + 6 = 16
    print ('tf.get_default_session() :',tf.get_default_session().run(dataCopy)) 
    # dataCopy + data5 = 16 + 6 = 22
print('End!')

结果:

加: 10
减: 2
乘: 24
除: 1.5
dataCopy : 10
dataCopy.eval() : 16
tf.get_default_session() : 22
End!

四、矩阵基础

1、矩阵操作

例子一:

data1 = tf.placeholder(tf.float32)
data2 = tf.placeholder(tf.float32)
dataAdd = tf.add(data1,data2)
with tf.Session() as sess:
    print(sess.run(dataAdd,feed_dict={data1:6,data2:2}))
print('End!')

结果:

8.0
End!

例子二:

data3 = tf.constant([[6,6]])
data4 = tf.constant([[2],
                    [2]])
data5 = tf.constant([[3,3]])
data6 = tf.constant([[1,2,3],
                    [4,5,6],
                    [7,8,9]])
print('data6.shape:',data6.shape) # 维度 
with tf.Session() as sess:
    print('data6:',sess.run(data6)) # 打印整体
    print('data6[0]:',sess.run(data6[0])) # 打印第一行
    print('data6[1,:]:',sess.run(data6[1,:])) # 第二行
    print('data6[:,1]:',sess.run(data6[:,1])) # 第二列
    print('data6[0,1]:',sess.run(data6[0,1])) # 第一行第二列

结果:

data6.shape: (3, 3)
data6: [[1 2 3]
 [4 5 6]
 [7 8 9]]
data6[0]: [1 2 3]
data6[1,:]: [4 5 6]
data6[:,1]: [2 5 8]
data6[0,1]: 2

2、矩阵运算

(1)加法 tf.add()

通常的矩阵加法被定义在两个相同大小的矩阵。两个m×n矩阵A和B的和,标记为A+B,一样是个m×n矩阵,其内的各元素为其相对应元素相加后的值。例如:

(2)减法 tf.subtract()

也可以做矩阵的减法,只要其大小相同的话。A-B内的各元素为其相对应元素相减后的值,且此矩阵会和A、B有相同大小。例如:

(3)乘法 tf.multiply()

设A为m×p的矩阵,B为p×n的矩阵,那么称的矩阵C为m×n矩阵A与B的乘积,记作C=AB,其中矩阵C中的第i行第j列元素可以表示为:

如下所示:

(4)乘积-哈达马积 tf.matmul()

m×n矩阵A=[a ij]与m×n矩阵B=[b ij]的HadamardAB积记为。其元素定义为两个矩阵对应元素的乘积(AB)ij=aij bij的m×n矩阵。例如,

data1 = tf.constant([[6,6]])
data2 = tf.constant([[2],
                    [2]])
data3 = tf.constant([[3,3],
                    [2,2]])
data4 = tf.constant([[1,2],
                    [3,4],
                    [5,6]])
data5 = tf.constant([[1,1],
                    [2,2]])

matMul = tf.matmul(data3,data5) 
matMul2 = tf.multiply(data1,data2) 
matAdd = tf.add(data1,data4) 

with tf.Session() as sess:
    print('matMul:',sess.run(matMul))
    print('matMul2:',sess.run(matMul2))
    print('matAdd:',sess.run(matAdd))

结果:

matMul: [[9 9]
 [6 6]]
matMul2: [[12 12]
 [12 12]]
matAdd: [[ 7  8]
 [ 9 10]
 [11 12]]