## dataloader实现

- (Pytorch)本身Pytorch数据处理比较规范：先定义Datasets类，初始化时生成list，实现__getitem__进行读取元素，并进行预处理操作，是一个可迭代对象；Dataloader类也是可迭代对象，iter(Dataloader)可实现next()访问,多线程加速batch data的处理，使用yield来使用有限的内存；内部还有queue操作；

- (通用)读数据最直接的方法：先准备所有样本list(image_name,image_label),在一个epoch中，shuffle后；依次按照index = (每个epoch进行迭代的次数len(list)/batch_size)*batch_size + j(当前batch的第j个文件)，这样来读取一张图，做预处理，收集满一个batch的数据；然后在喂进网络训练；(reference: https://github.com/GeorgeSeif/Semantic-Segmentation-Suite/blob/master/train.py ;https://github.com/joelthchao/tensorflow-finetune-flickr-style/blob/master/dataset.py),https://github.com/dgurkaynak/tensorflow-cnn-finetune/blob/master/utils/preprocessor.py]; 这样读取数据的正本多少呢？

- (Caffe)第二步非常慢：可以参考caffe自定义数据层：https://www.cnblogs.com/ranjiewen/p/9903826.html；该方式进行多进程读取数据process；

- Tensorflow读取数据方式：

        self.image_list, self.label_list = read_labeled_image_list(self.data_dir, self.data_list)

        self.images = tf.convert_to_tensor(self.image_list, dtype=tf.string)

        self.labels = tf.convert_to_tensor(self.label_list, dtype=tf.string)

        self.queue = tf.train.slice_input_producer([self.images, self.labels],

                                                   shuffle=input_size is not None) # not shuffling if it is val

self.image, self.label = read_images_from_disk(self.queue, self.input_size, random_scale, random_mirror, ignore_label, img_mean) 

       image_batch, label_batch = tf.train.batch([self.image, self.label],

num_elements)

第一个参数 tensor_list：包含一系列tensor的列表，表中tensor的第一维度的值必须相等，即个数必须相等，有多少个图像，就应该有多少个对应的标签。

第二个参数num_epochs: 可选参数，是一个整数值，代表迭代的次数，如果设置 num_epochs=None,生成器可以无限次遍历tensor列表，如果设置为 num_epochs=N，生成器只能遍历tensor列表N次。

第三个参数shuffle： bool类型，设置是否打乱样本的顺序。一般情况下，如果shuffle=True，生成的样本顺序就被打乱了，在批处理的时候不需要再次打乱样本，使用 tf.train.batch函数就可以了;如果shuffle=False,就需要在批处理时候使用 tf.train.shuffle_batch函数打乱样本。

第四个参数seed: 可选的整数，是生成随机数的种子，在第三个参数设置为shuffle=True的情况下才有用。

第五个参数capacity：设置tensor列表的容量。

第六个参数shared_name：可选参数，如果设置一个‘shared_name’，则在不同的上下文环境（Session）中可以通过这个名字共享生成的tensor。

第七个参数name：可选，设置操作的名称。

"""Output strings (e.g. filenames) to a queue for an input pipeline.

  Note: if `num_epochs` is not `None`, this function creates local counter

  `epochs`. Use `local_variables_initializer()` to initialize local variables.

  Args:

    string_tensor: A 1-D string tensor with the strings to produce.

    num_epochs: An integer (optional). If specified, `string_input_producer`

      produces each string from `string_tensor` `num_epochs` times before

      generating an `OutOfRange` error. If not specified,

      `string_input_producer` can cycle through the strings in `string_tensor`

      an unlimited number of times.

    shuffle: Boolean. If true, the strings are randomly shuffled within each

      epoch.

    seed: An integer (optional). Seed used if shuffle == True.

    capacity: An integer. Sets the queue capacity.

    shared_name: (optional). If set, this queue will be shared under the given

      name across multiple sessions. All sessions open to the device which has

      this queue will be able to access it via the shared_name. Using this in

      a distributed setting means each name will only be seen by one of the

      sessions which has access to this operation.

    name: A name for the operations (optional).

    cancel_op: Cancel op for the queue (optional).

  Returns:

    A queue with the output strings.  A `QueueRunner` for the Queue

    is added to the current `Graph`'s `QUEUE_RUNNER` collection.

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) 
第一个参数tensors：tensor序列或tensor字典，可以是含有单个样本的序列;
第二个参数batch_size: 生成的batch的大小;
第三个参数num_threads：执行tensor入队操作的线程数量，可以设置使用多个线程同时并行执行，提高运行效率，但也不是数量越多越好;
第四个参数capacity： 定义生成的tensor序列的最大容量;
第五个参数enqueue_many： 定义第一个传入参数tensors是多个tensor组成的序列，还是单个tensor;
第六个参数shapes： 可选参数，默认是推测出的传入的tensor的形状;
第七个参数dynamic_pad： 定义是否允许输入的tensors具有不同的形状，设置为True，会把输入的具有不同形状的tensor归一化到相同的形状;
第八个参数allow_smaller_final_batch： 设置为True，表示在tensor队列中剩下的tensor数量不够一个batch_size的情况下，允许最后一个batch的数量少于batch_size， 设置为False，则不管什么情况下，生成的batch都拥有batch_size个样本;
第九个参数shared_name： 可选参数，设置生成的tensor序列在不同的Session中的共享名称;
第十个参数name： 操作的名称; 

# -*- coding:utf-8 -*-

import tensorflow as tf

import numpy as np

# 样本个数

sample_num=5

# 设置迭代次数

epoch_num = 2

# 设置一个批次中包含样本个数

batch_size = 3

# 计算每一轮epoch中含有的batch个数

batch_total = int(sample_num/batch_size)+1

# 生成4个数据和标签

def generate_data(sample_num=sample_num):

    labels = np.asarray(range(0, sample_num))

    images = np.random.random([sample_num, 224, 224, 3])

    print('image size {},label size :{}'.format(images.shape, labels.shape))

    return images,labels

def get_batch_data(batch_size=batch_size):

    images, label = generate_data()

    # 数据类型转换为tf.float32

    images = tf.cast(images, tf.float32)

    label = tf.cast(label, tf.int32)

    #从tensor列表中按顺序或随机抽取一个tensor

    input_queue = tf.train.slice_input_producer([images, label], shuffle=False)

    image_batch, label_batch = tf.train.batch(input_queue, batch_size=batch_size, num_threads=1, capacity=64)

    return image_batch, label_batch

image_batch, label_batch = get_batch_data(batch_size=batch_size)

with tf.Session() as sess:

    coord = tf.train.Coordinator()

    threads = tf.train.start_queue_runners(sess, coord)

    try:

        for i in range(epoch_num):  # 每一轮迭代

            print '************'

            for j in range(batch_total): #每一个batch

                print '--------'

                # 获取每一个batch中batch_size个样本和标签

                image_batch_v, label_batch_v = sess.run([image_batch, label_batch])

                # for k in

                print(image_batch_v.shape, label_batch_v)

    except tf.errors.OutOfRangeError:

        print("done")

    finally:

        coord.request_stop()

    coord.join(threads)