Tensorflow

1. tf.FIFOQueue

   FIFOQueue类基于基类QueueBase．QueueBase主要包含入列（enqueue）和出列（dequeue）两个操作．enqueue操作返回计算图中的一个Operation节点，dequeue操作返回一个Tensor值．Tensor在创建时同样只是一个定义，需要放在Session中运行才能获得真正的数值．
   引用来源

   #!/usr/bin/python
   # coding:utf-8
   
   # 队列与多线程
   import tensorflow as tf
   
   # 创建一个先入先出的队列,指定队列最多可以保存3个元素,并指定类型为整数
   q = tf.FIFOQueue(3, 'int32')
   # 初始化队列中的元素,将[0,10,20]3个元素排入此队列
   init = q.enqueue_many(([0, 10, 20], ))
   # 将队列中的第1个元素出队列,并存入变量x中
   x = q.dequeue()
   # 将得到的值加1
   y = x + 1
   # 将加1后的值重新加入队列
   q_inc = q.enqueue([y])
   
   with tf.Session() as sess:
       # 队列初始化
       init.run()
       for _ in range(5):
           # 执行数据出队列/出队元素+1/重新加入队列的过程
           v, _ = sess.run([x, q_inc])
           print v
   

2. tf.RunOptions
   TensorBoard 默认是不会记录每个节点的用时、耗费的内存大小等这些信息的，那么如何才能在图上显示这些信息呢？关键就是如下这些代码，主要就是在 sess.run() 中加入 options 和 run_metadata 参数。
   更多引用

   #定义TensorFlow运行选项，设置trace_lever FULL_TRACE
   run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
   #定义TensorFlow运行元信息，记录训练运算时间和内存占用等信息
   run_metadata = tf.RunMetadata()
   summary, _ = sess.run([merged, train_step],feed_dict=feed_dict(True),options=run_options,run_metadata=run_metadata)
   train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
   train_writer.add_summary(summary, i)
   

3. tf.train.Coordinator()

   更多引用

   # 使用 coord.should_stop()来查询是否应该终止所有线程，当文件队列（queue）中的所有文件都已经读取出列的时候，会抛出一个 OutofRangeError 的异常，这时候就应该停止Sesson中的所有线程了;
   def enqueue(sess, coord):
       with coord.stop_on_exception():
           while not coord.should_stop():
               sess.run(enqueue_op)
               # enqueue_op = q.enqueue([vars])
               # q ~ tf.FIFOQueue()
   
   coord = tf.train.Coordinator()
   enq_threads = []
   for _ in range(thread_number):
       eqth = threading.Thread(target=enqueue, args=[sess, coord])
       eqth.start()
       enq_threads.append(eth)
       
   try:
       # some training
   except Exception, e:
       # 使用coord.request_stop()来发出终止所有线程的命令
       coord.request_stop(e)
   finally:
       # 使用coord.request_stop()来发出终止所有线程的命令，使用coord.join(threads)把线程加入主线程，等待threads结束。 
       coord.request_stop()
       sess.run(q.close(cancel_pending_enqueues=True))
       coord.join(enq_threads)
   

4. tf.control_dependencies()

   def _add_train_graph(self):
       """Define the training operation."""
       mc = self.mc
       
       self.global_step = tf.Variable(0, name='global_step', trainable=False)
       lr = tf.train.exponential_decay(mc.LEARNING_RATE,
                                       self.global_step,
                                       mc.DECAY_STEPS,
                                       mc.LR_DECAY_FACTOR,
                                       staircase=True)
       
       tf.summary.scalar('learning_rate', lr)
       
       opt = tf.train.MomentumOptimizer(learning_rate=lr, momentum=mc.MOMENTUM)
       grads_vars = opt.compute_gradients(self.loss, tf.trainable_variables())
       
       with tf.variable_scope('clip_gradient') as scope:
           for i, (grad, var) in enumerate(grads_vars):
               grads_vars[i] = (tf.clip_by_norm(grad, mc.MAX_GRAD_NORM), var)
       
       apply_gradient_op = opt.apply_gradients(grads_vars, global_step=self.global_step)
       
       with tf.control_dependencies([apply_gradient_op]):
           self.train_op = tf.no_op(name='train')
   

   如上：

   • tf.train.exponential_decay
     在Tensorflow中，通过tf.train.exponential_decay函数实现指数衰减学习率。

     decayed_learning_rate = \
     learining_rate * decay_rate ^ \
     (global_step / decay_steps) 
     
     1. decayed_learning_rate为每一轮优化时使用的学习率；
     2. learning_rate为事先设定的初始学习率；
     3. decay_rate为衰减系数；
     4. decay_steps为衰减速度。
     

     通常初始学习率，衰减系数，衰减速度的设定具有主观性(即经验设置)，而损失函数下降的速度与迭代结束之后损失的大小没有必然联系，

   • tf.trainable_variables返回的是需要训练的变量列表，tf.all_variables返回的是所有变量的列表

     import tensorflow as tf;  
     import numpy as np;  
     import matplotlib.pyplot as plt;  
      
     v = tf.Variable(tf.constant(0.0, shape=[1], dtype=tf.float32), name='v')
     v1 = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='v1')
      
     global_step = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='global_step', trainable=False)
     ema = tf.train.ExponentialMovingAverage(0.99, global_step)
      
     for ele1 in tf.trainable_variables():
         print ele1.name
     for ele2 in tf.all_variables():
         print ele2.name
     

     输出：
     v:0
     v1:0

     v:0
     v1:0
     global_step:0

     分析：

     上面得到两个变量，后面的一个得到上三个变量，因为global_step在声明的时候说明不是训练变量，用来关键字trainable=False。

   • tf.clip_by_norm
     梯度裁剪的最直接目的就是防止梯度爆炸，手段就是控制梯度的最大范式。

   • tf.control_dependencies
     在执行某些op,tensor之前，某些op,tensor得首先被运行。

   • tf.no_op
     什么都不做，仅做为点位符使用控制边界。

5. tf.device

   使用多个GPU训练模型, 引用链接
   参考官方链接， cifar10_multi_gpu_train.py

备注知识点

• tensorflow 新版取消了tf.train.SummaryWriter()，换成使用tf.summary.FileWriter()；
• tf里面提供模型保存的是tf.train.Saver()模块;
• 训练过程中，主要用到了tf.summary()的各类方法，能够保存训练过程以及参数分布图并在tensorboard显示;
• tf.Variable设定trainable=False 可以防止该变量被数据流图的 GraphKeys.TRAINABLE_VARIABLES 收集,
  这样我们就不会在训练的时候尝试更新它的值。