Python学习记录-FIFOQueue ...

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 收集,
    这样我们就不会在训练的时候尝试更新它的值。

你可能感兴趣的:(Python学习,python,tensorflow,FIFOQueue)