TensorFlow的简单认识

    在成功安装完成TensorFlow后，对TensorFlow有了个简单的认识，了解和运行了一下TensorFlow的基本流程。

# TensorFlow的几个基本概念
'''
使用TensorFlow, 必须明白:
    TensorFlow使用图(graph)来表示计算任务.
    TensorFlow在被称之为会话(Session)的上下文(context)中执行图.
    TensorFlow使用张量(tensor)表示数据.
    TensorFlow通过变量(Variable)维护状态.
    TensorFlow使用feed和fetch可以为任意的操作(arbitrary operation)赋值或者从其中获取数据.
'''


# TensorFlow的基本流程
'''
TensorFlow是一个编程系统, 使用图来表示计算任务. 图中的节点被称之为op(operation的缩写).
一个op获得0个或多个Tensor, 执行计算, 产生0个或多个Tensor. 每个Tensor是一个类型化的多维数组.
一个TensorFlow图描述了计算的过程. 为了进行计算, 图必须在会话里被启动. 
会话将图的op分发到诸如CPU或GPU之类的设备上, 同时提供执行op的方法. 
这些方法执行后, 将产生的tensor返回. 
'''


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


# TensorFlow的构建图
'''
构建图的第一步, 是创建源op(source op).源op不需要任何输入, 例如常量(Constant). 源op的输出被传递给其它op做运算.
Python库中,op构造器的返回值代表被构造出的op的输出,这些返回值可以传递给其它op构造器作为输入.
TensorFlow Python库有一个默认图 (default graph), op构造器可以为其增加节点.这个默认图对许多程序来说已经足够用了.
'''


# TensorFlow的会话启动图
'''
构造阶段完成后, 才能启动图. 
启动图的第一步是创建一个Session对象, 如果无任何创建参数, 会话构造器将启动默认图.
Session对象在使用完后需要关闭以释放资源. 除了显式调用close外, 也可以使用"with"代码块 来自动完成关闭动作.


在实现上,TensorFlow将图形定义转换成分布式执行的操作,以充分利用可用的计算资源(如CPU或GPU). 
一般你不需要显式指定使用CPU还是GPU,TensorFlow能自动检测.如果检测到GPU,TensorFlow会尽可能地利用找到的第一个GPU来执行操作.
如果机器上有超过一个可用的GPU,除第一个外的其它GPU默认是不参与计算的. 
为了让TensorFlow使用这些GPU, 你必须将op明确指派给它们执行. 
with...Device语句用来指派特定的CPU或GPU执行操作:


with tf.Session() as sess:
  with tf.device("/gpu:1"):
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.],[2.]])
    product = tf.matmul(matrix1, matrix2)
    ...
设备用字符串进行标识. 目前支持的设备包括:
"/cpu:0": 机器的CPU.
"/gpu:0": 机器的第一个GPU,如果有的话.
"/gpu:1": 机器的第二个GPU,以此类推.
'''


# TensorFlow的张量Tensor和变量Variables
'''
TensorFlow程序使用tensor数据结构来代表所有的数据,计算图中,操作间传递的数据都是tensor. 
可以把TensorFlow张量tensor看作是一个n维的数组或列表.


变量Variables维护图执行过程中的状态信息. 
'''


# TensorFlow的Fetch和Feed
'''
Fetch是为了取回操作的输出内容,可以在使用Session对象的run()调用执行图时,传入一些tensor,这些tensor会帮助你取回结果.


TensorFlow还提供了feed机制,该机制可以临时替代图中的任意操作中的tensor可以对图中任何操作提交补丁,直接插入一个tensor.
可以提供feed数据作为run()调用的参数.feed只在调用它的方法内有效,方法结束,feed就会消失.
'''

########################################################################################################################
# 对以上介绍的东东下面将以实例进行demo
########################################################################################################################




# 以tf的简称导入tensorflow模块库
import tensorflow as tf



# 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
# TensorFlow程序通常被组织成一个构建阶段和一个执行阶段.
# 首先构建图......


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


# 创建另外一个常量op2,产生一个 2x1 矩阵. 这个op2也被作为一个节点
matrix2 = tf.constant([[2.],[2.]])


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


# 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
# TensorFlow程序通常被组织成一个构建阶段和一个执行阶段.
# 然后启动图......


# 启动默认图.
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.]]
# 任务完成, 关闭会话.Session 对象在使用完后需要关闭以释放资源.
sess.close()


# 除了显式调用 close 外, 也可以使用 "with" 代码块 来自动完成关闭动作.
with tf.Session() as sess:
    result = sess.run(product)
    print (result)




# 3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
# TensorFlow将图形定义转换成分布式执行的操作,以充分利用可用的计算资源(如CPU或GPU).
# 启动图......
with tf.Session() as sess:
    with tf.device("/cpu:0"):
        matrix1 = tf.constant([[3., 3.]])
        matrix2 = tf.constant([[2.],[2.]])
        product = tf.matmul(matrix1, matrix2)
    result = sess.run(product)
    print (result) # ==> [[ 12.]]




# 4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
# 为了便于使用Python交互环境,可以使用InteractiveSession代替Session
# 使用Tensor.eval()和Operation.run()方法代替Session.run().这样可以避免使用一个变量来持有会话.


# 进入一个交互式 TensorFlow 会话.
sess = tf.InteractiveSession()


x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])


# 使用初始化器initializer op 的 run() 方法初始化 'x',  变量是需要初始化的,下面会有介绍
x.initializer.run()


# 增加一个加法 add op,  'x' 加 'a'. 运行加法 op, 输出结果
result = tf.add(x, a)


print (result.eval())
# ==> [ 4.  5.]
sess.close()




# 5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
# TensorFlow 张量Tensor 变量Variables
# 注意print的结果


# 创建一个变量, 初始化为标量 0.
state = tf.Variable(0)
print(state)


# 创建一个 op,
one = tf.constant(1)
print(one)


# 创建一个 op, 其作用是使 state 增加 1
new_value = tf.add(state, one)
print(new_value)


# 这个节点的op是把state节点和one节点相加赋值给state
update = tf.assign(state, new_value)
print(update)


# 启动图后, 变量必须先经过`初始化` (init) op 初始化,
# 首先必须增加一个`初始化` op 到图中.
init_op = tf.global_variables_initializer()


# 启动图, 运行 op
with tf.Session() as sess:
  # 运行 'init' op
  sess.run(init_op)
  # 打印 'state' 的初始值
  print (sess.run(state))
  # 运行 op, 更新 'state', 并打印 'state'
  for _ in range(3):
    sess.run(update)
    print (sess.run(state))
# 输出:
# 0
# 1
# 2
# 3




# 6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
# TensorFlow的Fetch和Feed


# TensorFlow的Fetch
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)


intermed = tf.add(input2, input3)


mul = tf.multiply(input1, intermed)


with tf.Session() as sess:
    # result获取的多个tensor值, 在op的一次运行中一起获得(而不是逐个去获取tensor)  这就是Fetch
    result = sess.run([mul, intermed])
    print (result)
# 输出:
# [21.0, 7.0]


# TensorFlow的Feed
# feed使用一个tensor值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数.
# feed只在调用它的方法内有效, 方法结束, feed 就会消失.
# 最常见的用例是将某些特殊的操作指定为 "feed" 操作,标记的方法是使用 tf.placeholder()为这些操作创建占位符.
input1 = tf.placeholder("float32")
input2 = tf.placeholder("float32")


output = tf.multiply(input1, input2)


with tf.Session() as sess:
    result = sess.run([output], feed_dict={input1:[7.], input2:[2.]})
    print (result)
# 输出:
# [array([ 14.], dtype=float32)]




# 6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
# TensorFlow的扩展认识
# 再给一些简单的实例进一步的熟识TensorFlow的运行概念
print ('TensorFlow的扩展认识')
#######################
# 定义两个不同的计算图
#######################
print ('定义两个不同的计算图')
g1 = tf.Graph()
with g1.as_default():
    state = tf.Variable(0)
    one = tf.constant(1)
    new_value = tf.add(state, one)
    update = tf.assign(state, new_value)


g2 = tf.Graph()
with g2.as_default():
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.], [2.]])
    product = tf.matmul(matrix1, matrix2)




with tf.Session(graph = g1) as sess:
    tf.global_variables_initializer().run()
    # 打印 'state' 的初始值
    print (sess.run(state))
    # 运行 op, 更新 'state', 并打印 'state'
    for _ in range(3):
        sess.run(update)
        print (sess.run(state))


with tf.Session(graph = g2) as sess:
    tf.global_variables_initializer().run()
    result = sess.run(product)
    print (result)




#######################
# 进一步熟识张量Tensor
#######################
'''
张量结构的三个属性:名字name  维度shape  类型type


name是一个张量的唯一标识符,也给出了这个张量是如何计算出来的.
name冒号后面的数字编号表示这个张量是计算节点上的第几个结果.


shape显示了几个数据就表示是几维的,此数据表示此维度的大小.
shape=(2,)表示是1维数组,此维度的长度为2.


type TensorFlow主要的数据类型有
               np.bool:    (False, True),
               np.bool8:   (False, True),
               np.uint8:   (0, 255),
               np.uint16:  (0, 65535),
               np.int8:    (-128, 127),
               np.int16:   (-32768, 32767),
               np.int64:   (-2**63, 2**63 - 1),
               np.uint64:  (0, 2**64 - 1),
               np.int32:   (-2**31, 2**31 - 1),
               np.uint32:  (0, 2**32 - 1),
               np.float32: (-1, 1),
               np.float64: (-1, 1)}
'''
print ('进一步熟识张量Tensor')
# tf.constant是一个计算op,这个op的结果为一个张量,保存在变量a中.
a = tf.constant([1.0, 2.0], name="a")
print (a)   # Tensor("a:0", shape=(2,), dtype=float32)
b = tf.constant([2.0, 3.0], name="b")
print (b)    # Tensor("b:0", shape=(2,), dtype=float32)


result = a + b
print (result)
'''
输出:
Tensor("add:0", shape=(2,), dtype=float32)
'''


# 通过会话(session)得到张量中的具体数值
sess = tf.InteractiveSession ()
print(result.eval())
sess.close()




#######################
# 进一步熟识会话(session)
#######################
print ('进一步熟识会话(session)')
a = tf.constant([1.0, 2.0], name="a")
b = tf.constant([2.0, 3.0], name="b")
result = a + b


'''
会话(session)拥有并管理tensorflow程序运行时的所有资源。
当所有计算完成之后需要关闭会话来帮助系统回收资源，否则就可能出现资源泄漏的问题。
'''
# 1 通过明确调用会话生成函数和关闭会话函数
sess = tf.Session()      # 创建一个会话。
print(sess.run(result))  # 使用会话得到之前计算的结果。
sess.close()             # 关闭会话使得本次运行中使用到的资源可以被释放。


# 2 使用with statement来创建会话
'''
通过Python的上下文管理器的机制来使用会话。
只要将所有的计算放在"with"的内部就可以，当上下文管理器退出时会话关闭且会自动释放所有资源。
'''
with tf.Session() as sess:
    print(sess.run(result))


# 3 指定默认会话
sess = tf.Session()
with sess.as_default():
     print(result.eval())


sess = tf.Session()
# 下面的两个命令有相同的功能。
print(sess.run(result))
print(result.eval(session=sess))
sess.close()


# 4 使用tf.InteractiveSession直接构建默认会话
sess = tf.InteractiveSession ()
print(result.eval())
sess.close()


# 5 通过ConfigProto配置会话
'''
参数allow_soft_placement
布尔型参数，默认为False。
为了使代码的可移植性更强，在有GPU的环境下常设置为True：
为True时，可以让程序在拥有不同数量的GPU机器上顺利运行。
当某些运算无法被当前GPU支持时(不同的GPU不同的驱动版本等等)，可以自动调整到CPU上而不是报错。
以下任意一个条件成立时，GPU上的运算是可以放到CPU上的：
 1.运算无法在GPU上执行
 2.没有GPU资源
 3.运算输入包含对CPU计算结果的引用


参数log_device_placement
布尔型参数，为True时日志中将会记录每个节点被安排在了哪个设备上。
主要是为了调试方便，而在真实的应用环境中常设置为False以减少日志量。
'''
config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)
sess1 = tf.InteractiveSession(config=config)
print(result.eval())
sess1.close()


sess2 = tf.Session(config=config)
print(sess2.run(result))
sess2.close()


print ('进一步熟识会话(session) 图')
with tf.Session(config=config) as sess:
#with tf.Session() as sess:
    with tf.device("/gpu:0"):
        matrix1 = tf.constant([[3., 3.]])
        matrix2 = tf.constant([[2.],[2.]])
        product = tf.matmul(matrix1, matrix2)
    result = sess.run(product)
    print (result) # ==> [[ 12.]]

以上的代码有现成的代码文件：http://download.csdn.net/detail/chenleiyfk/9842097