TensorFlow基础入门
TensorFlow简介
TensorFlow是一个采用数据流图(data flow graphs),用于数值计算的开源软件库。最初由Google大脑小组(隶属于Google机器智能研究机构)的研究员和工程师们开发出来,用于机器学习和深度神经网络方面的研究,但这个系统的通用性使其也可广泛用于其他计算领域。TensorFlow既是一个实现机器学习算法的接口,同时也是执行机器学习速算法的框架。它前端支持Python、C++、Go、Java等多种开发语言,后端使用C++、CUDA等写成,其实现的算法可以在众多异构系统移植,如CPU,GPU集群,iOS,Android等。
  TensorFlow中的计算可以表示为一个有向图(directed graph),或计算图(computation graph),其中每一个运算操作将作为一个节点,称之为op(operation缩写),节点与节点之间的连接称为边(edge)。在计算图的边中流动(flow)的数据被称>为张量(tensor),因此得名为TensorFlow。每个张量是一个类型化的多维数组。例如,可以将一小组图像集表示为一个四维浮点数数组,这四个维度分别是[batch, height, width, channels]。
基础使用
  一个TensorFlow图描述了计算的过程。为了进行计算,图必须在会话里被启动。会话将图的op分发到诸如CPU或GPU之类的设备上,同时提供执行op的方法。这些方法执行后,将产生的tensor返回。在Python语言中,返回的tensor是numpy ndarray对象。
### 计算图
  TensorFlow程序通常被组织成一个构建阶段和一个执行阶段。在构建阶段,op的执行步骤被描述成一个图。在执行阶段,使用会话执行执行图中的op。例如,通常在构建阶段创建一个图来表示和训练神经网络,然后在执行阶段反复执行图中的训练op。
构建图
  构建图的第一步,是创建源op(source op)。源op不需要任何输入,例如常量(Constant)。源op的输出被传递给其它op做运算。Python库中,op构造器的返回值代表被构造出的op的输出,这些返回值可以传递给其它op构造器作为输入。TensorFlow Python库有一个默认图(default graph),op构造器可以为其增加节点。这个默认图对许多程序来说已经足够用了。
 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。为了真正进行矩阵相乘运算,并得到矩阵乘法的结果,必须在会话里启动这个图。
#### 启动图
  构造阶段完成后,才能启动图。启动图的第一步是创建一个Session对象,如果无任何创建参数,会话构造器将启动默认图。
 # 启动默认图.                                                                    
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()
  Session对象在使用完后需要关闭以释放资源。除了显式调用close外,也可以使用“with”代码块来自动完成关闭动作。
 with tf.Session() as sess:                                                       
result = sess.run([product])                                                     
print result
变量
  变量维护图执行过程中的状态信息。下面的例子演示了如何使用变量实现一个简单的计数器。
 # 创建一个变量, 初始化为标量 0.                                                  
state = tf.Variable(0, name="counter")                                           
# 创建一个 op, 其作用是使 state 增加 1     
                                                                                 
one = tf.constant(1)                                                             
new_value = tf.add(state, one)                                                   
update = tf.assign(state, new_value)                                             
                                                                                 
# 启动图后, 变量必须先经过`初始化` (init) op 初始化,                             
# 首先必须增加一个`初始化` op 到图中.                                            
init_op = tf.initialize_all_variables()                                          
                                                                                 
# 启动图, 运行 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
  代码中assign()操作是图所描绘的表达式的一部分,正如add()操作一样。所以在调用run()执行表达式之前,它并不会真正执行赋值操作。
   通常会将一个统计模型中的参数表示为一组变量。例如,可以将一个神经网络的权重作为某个变量存储在一个tensor中。在训练过程中,通过重复运行训练图,更新这个tensor。
Fetch
  为了取回操作的输出内容,可以在使用Session对象的run()。调用执行图时,传入一些tensor,这些tensor会帮助你取回结果。在之前的例子里,只取回了单个节点state,但是也可以取回多个tensor:
 input1 = tf.constant(3.0)                                                        
input2 = tf.constant(2.0)          
intermed = tf.add(input2, input3)                                                
mul = tf.mul(input1, intermed)                                                   
                                                                                 
with tf.Session():                                                               
  result = sess.run([mul, intermed])                                             
  print result                                                                   
                                                                                 
# 输出:                                                                          
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
  需要获取的多个tensor值,在op的一次运行中一起获得(而不是逐个去获取tensor)。
Feed
  上述示例在计算图中引入了tensor,以常量或变量的形式存储。TensorFlow还提供了feed机制,该机制可以临时替代图中的任意操作中的tensor可以对图中任何操作提交补丁,直接插入一个tensor。
   feed使用一个tensor值临时替换一个操作的输出结果。可以提供feed数据作为run()调用的参数。feed只在调用它的方法内有效,方法结束,feed就会消失。最常见的用例是将某些特殊的操作指定为“feed”操作,标记的方法是使用tf.placeholder()为这些操作创建占位符。
 input1 = tf.placeholder(tf.types.float32)                                        
input2 = tf.placeholder(tf.types.float32)                                        
output = tf.mul(input1, input2)                                                  
                                                                                 
with tf.Session() as sess:                                                       
  print sess.run([output], feed_dict={input1:[7.], input2:[2.]})                 
                                                                                 
# 输出:                                                                          
# [array([ 14.], dtype=float32)]
  如果没有正确提供feed,placeholder()操作将会产生错误。