[Reserved] tf.train.slice_input_producer () and tf.train.batch ()

Original Address:

https://www.jianshu.com/p/8ba9cfc738c2

 

 

 

------------------------------------------------------------------------------------------------

 

 

 

 

1.          tf.train.slice_input_producer  function, a model that the queuing data input method.

tf.train.slice_input_producer(
    tensor_list,
    num_epochs=None, 
    shuffle=True,
    seed=None,
    capacity=32,
    shared_name=None,
    name=None
)

 

 

Its parameters are:

Args:
tensor_list: A list of Tensor objects. 
Every Tensor
in tensor_list must have the same size in the first dimension.

# 循环Queue输入次数 num_epochs: An integer (optional).
If specified, slice_input_producer produces each slice num_epochs times before generating an OutOfRange error.
If not specified, slice_input_producer can cycle through the slices an unlimited number of times.
shuffle: Boolean. If true, the integers are randomly shuffled within each epoch. seed: An integer (optional). Seed used
if shuffle == True.

# Queue的容量 capacity: An integer. Sets the queue capacity. shared_name: (optional). If set, this queue will be shared under the given name across multiple sessions. name: A name for the operations (optional).

 

 

 

 

The relevant code examples:

    # Generates an input image and a target address name List 
    input_files = [the os.path.join (dirname, ' INPUT ' , F) for F in flist] 
    output_files = [the os.path.join (dirname, ' Output ' , F) for F in flist] 

    # internal automatically converted to the Constant String Tensor, and queued into the queue 
    input_queue, output_queue = tf.train.slice_input_producer ( 
        [input_files, output_files], shuffle = self.shuffle, 
        SEED = 0123, num_epochs = self.num_epochs ) 

    # tf.train.slice_input_producer () each take one pair [input - target] right, to which ReadFile
    # 个Op
    input_file = tf.read_file(input_queue)
    output_file = tf.read_file(output_queue)
    
    # 生成RGB格式的图像tensor
    im_input = tf.image.decode_jpeg(input_file, channels=3)
    im_output = tf.image.decode_jpeg(output_file, channels=3)

 

 

 

 

 

 

 

 

 

 

 

2.          tf.train.batch()Functions

tf.train.batch(
    tensors,
    batch_size,
    num_threads=1,
    capacity=32,
    enqueue_many=False,
    shapes=None,
    dynamic_pad=False,
    allow_smaller_final_batch=False,
    shared_name=None,
    name=None
)

 

 

 

Its parameters are:

Args:
tensors: The list or dictionary of tensors to enqueue.
batch_size: The new batch size pulled from the queue.
num_threads: The number of threads enqueuing tensors. The batching will be nondeterministic if num_threads > 1.
capacity: An integer. The maximum number of elements in the queue.
#进行shuffle的输入是否为单个tensor enqueue_many: Whether each tensor in tensors is a single example. shapes: (Optional) The shapes for each example. Defaults to the inferred shapes for tensors.

dynamic_pad: Boolean.
Allow variable dimensions
in input shapes.
The given dimensions are padded upon dequeue so that tensors within a batch have the same shapes.

allow_smaller_final_batch: (Optional) Boolean.
If True, allow the final batch to be smaller
if there are insufficient items left in the queue.

shared_name: (Optional).
If set, this queue will be shared under the given name across multiple sessions.

name: (Optional) A name
for the operations.

 

 

 

The relevant code examples

samples = tf.train.batch(
        sample,
        batch_size=self.batch_size,
        num_threads=self.nthreads,
        capacity=self.capacity)

 

Guess you like

Origin www.cnblogs.com/devilmaycry812839668/p/10961041.html