文章均迁移到我的主页 http://zhenlianghe.com

my github: https://github.com/LynnHo

input_producer

1. input_producer(input_tensor, element_shape=None, num_epochs=None, shuffle=True, seed=None, capacity=32, shared_name=None, summary_name=None, name=None, cancel_op=None)

   • 大概流程就是input_tensor (-> shuffle) -> FIFOQueue
   • 可以看出，shuffle是在进入队列之前完成的（出队不是随机的，因为是先进先出队列）
   • capacity代表的是队列的容量
   • 返回的是一个队列对象
   • Note: if num_epochs is not None, this function creates local counter epochs. Use local_variables_initializer() to initialize local variables.

2. string_input_producer

   • 简单封装了一下input_producer而已
   • 输入是一个string tensor，返回一个string tensor的队列

     sess = tf.Session()
     a = tf.train.string_input_producer(['a', 'b'], shuffle=False)
     b = a.dequeue_many(4)
     
     coord = tf.train.Coordinator()
     threads = tf.train.start_queue_runners(sess=sess, coord=coord)    # 注意，先调用这个函数来启动所有的queue
     print(sess.run(b))
     
     [out]
     ['a' 'b' 'a' 'b']
     

   • Note: if num_epochs is not None, this function creates local counter epochs. Use local_variables_initializer() to initialize local variables.

3. range_input_producer(limit, ...)

   • 同样是简单封装了一下input_producer而已
   • 输入一个limit，然后让[0, limit)的整数（随机）入队
   • 返回一个队列对象
   • Note: if num_epochs is not None, this function creates local counter epochs. Use local_variables_initializer() to initialize local variables.

4. slice_input_producer(tensor_list, ...)

   • 封装了range_input_producer
   • tensor_list是一个列表，其中每个元素的形状都是(N, ...)
   • 与上述producer不同，该函数返回的是一个tensor列表，而并非队列，实际上就是已经出队了，并且只出队一个元素，源码如下

   
   with ops.name_scope(name, "input_producer", tensor_list):
     tensor_list = ops.convert_n_to_tensor_or_indexed_slices(tensor_list)
     if not tensor_list:
       raise ValueError(
           "Expected at least one tensor in slice_input_producer().")
     range_size = array_ops.shape(tensor_list[0])[0]
     # TODO(josh11b): Add an assertion that the first dimension of
     # everything in TensorList matches. Maybe just check the inferred shapes?
     queue = range_input_producer(range_size, num_epochs=num_epochs,
                                  shuffle=shuffle, seed=seed, capacity=capacity,
                                  shared_name=shared_name)
     index = queue.dequeue()
     output = [array_ops.gather(t, index) for t in tensor_list]
     return output
   

   • 从上述源码看出，返回的也是一个list -> [t[i] for t in tensor_list]
   • Note: if num_epochs is not None, this function creates local counter epochs. Use local_variables_initializer() to initialize local variables.

batch

1. batch(tensors, ...)

   • 输入tensors是一个list或dictionary，可以将这个tensors理解为一个样本，包含的不同属性，比如tensors = {'img': img, 'label': label}
   • 维护一个FIFOQueue，tensors将入队，并先入先出，没有随机性
   • 返回的是出队之后的一个batch的tensors，对应上述tensors，返回={'img': imgs, 'label': labels}
   • 这个函数有一个参数是num_threads，即多线程入队！！这时候，由于多线程的时间顺序不确定，因此入队的顺序也将不确定，相当于一个小shuffle了

2. shuffle_batch(tensors, ...)

   • 基本同上
   • 维护一个RandomShuffleQueue，这个Queue在出队的时候是随机的！
   • 同样也有一个num_threads参数，即多线程入队
   • 所以说，这个shuffle体现在两点
     • 多线程入队，但是这个shuffle的范围仅限于线程数，因此随机效果几乎忽略不计
     • 随机出队！主要shuffle的功效体现在随机出队，但需要注意的是，如果队列中的元素过少，随机性就会小，所以函数提供了一个min_after_dequeue来限制队列中的最少元素个数

3. shuffle_batch_join(tensors_list, ...)

   • 上述的两个batch操作基本都是给定了一个tensor，然后函数里面将定义对这个tensor的入队操作
   • 该函数则是给定一个list的tensor，对这个list的tensor进行多线程入队，就是说list里面有多少个tensor，就有多少个线程，每个线程负责其中一个tensor的入队
   • 该函数能实现文件间样本的shuffle，详见http://wiki.jikexueyuan.com/project/tensorflow-zh/how_tos/reading_data.html