[Kaggle] dogs-vs-cats之制作数据集[1]

Step 0：导入必要的库

import tensorflow as tfimport os

Step 1：获取图片文件名以及对应的标签

首先是读取给定路径下所有图片的名称以及对应的标签。os.listdir(file_dir)可以列出file_dir路径下所有文件名；str.split(sep='.')将字符串str以点（.）分割。

# you need to change this to your data directory
train_dir = 'E:\\data\\Dog_Cat\\train\\'#Windows
#train_dir = '/home/kevin/tensorflow/cats_vs_dogs/data/train/'#linux
#获取给定路径下图片名及其对应的标签
def get_files(file_dir):
    '''
    Args:
        file_dir: file directory
    Returns:
        list of images and labels
    '''
    images=[]
    labels=[]
    for file in os.listdir(file_dir):
        name = file.split(sep='.')
        if name[0]=='cat':
            images.append(file_dir + file)
            labels.append(0)
        else:
            images.append(file_dir + file)
            labels.append(1)
    return images, labels

step3:分批次读取图片

由于图片数量太多，如果一次性将全部图片读入内存的话，可能会造成内存不够用的情况，因此需要分批次地将图片读入内存中。我们可以利用tensorflow的tf.train.slice_input_producer函数，利用队列的思想实现。

def get_batch(image, label, image_W, image_H, batch_size, capacity):
    '''
    Args:
        image: list type
        label: list type
        image_W: image width
        image_H: image height
        batch_size: batch size
        capacity: the maximum elements in queue
    Returns:
        image_batch: 4D tensor [batch_size, width, height, 3], dtype=tf.float32
        label_batch: 1D tensor [batch_size], dtype=tf.int32
    '''
    #将python的list数据类型转换为tensorflow的数据类型
    #image = tf.cast(image, tf.string)
    #label = tf.cast(label, tf.int32)

    image = tf.convert_to_tensor(image, dtype=tf.string)
    label = tf.convert_to_tensor(label, dtype=tf.int32)

    # make an input queue  生成一个队列,shuffle=True即将图片打乱放入队列中
    input_queue = tf.train.slice_input_producer([image, label],shuffle=True)

    label = input_queue[1] #获取label对应的队列
    image_contents = tf.read_file(input_queue[0])#读取图片
    image = tf.image.decode_jpeg(image_contents, channels=3)#解码jpg格式图片

    ######################################
    # data argumentation should go to here
    ######################################
    #图片resize
    image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)

    # if you want to test the generated batches of images, you might want to comment the following line.
    # 如果想看到正常的图片，请注释掉111行（标准化）和 126行（image_batch = tf.cast(image_batch, tf.float32)）
    # 训练时不要注释掉！
    #数据标准化
    image = tf.image.per_image_standardization(image)
    #Creates batches of tensors in tensors.
    image_batch, label_batch = tf.train.batch([image, label],
                                                batch_size= batch_size,
                                                num_threads= 2, #线程数设置
                                                capacity = capacity) #队列中最多能容纳的元素

    #you can also use shuffle_batch
#    image_batch, label_batch = tf.train.shuffle_batch([image,label],
#                                                      batch_size=BATCH_SIZE,
#                                                      num_threads=64,
#                                                      capacity=CAPACITY,
#                                                      min_after_dequeue=CAPACITY-1)

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

    return image_batch, label_batch

首先，我们需要先把image和label转换成tensorflow的tensor相关数据类型；其次，我们需要将images和labels放入队列中，需要注意的是要设置shuffle=True将顺序打乱（默认shuffle=True）。然后通过tf.read_file和tf.image.decode_jpeg函数读取图片已经将其进行解码。接下来就是重新调整图片大小（通过crop或者pad的方式实现）和将图像归一化。最后就是利用tf.train.batch读取队列中batch_size个数的图像及其对应的标签。

测试：

　　接下来就是测试上面写的代码是否正确。

import matplotlib.pyplot as plt

BATCH_SIZE = 4
CAPACITY = 256
#图片resize后的大小
IMG_W = 208
IMG_H = 208

#train_dir = '/home/kevin/tensorflow/cats_vs_dogs/data/train/'
train_dir = 'E:\\data\\Dog_Cat\\train\\'
image_list, label_list = get_files(train_dir)
image_batch, label_batch = get_batch(image_list, label_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)

with tf.Session() as sess:#在会话中运行程序
    i = 0
    coord = tf.train.Coordinator()#线程协调者
    threads = tf.train.start_queue_runners(coord=coord)

    try:
        #        Check if stop was requested.
        while not coord.should_stop() and i<1:

            img, label = sess.run([image_batch, label_batch])
            print(img[0,:,:,:])
            # just test one batch
            for j in range(BATCH_SIZE):
                print('label: %d' %label[j])
                plt.imshow(img[j,:,:,:])
                plt.show()
            i+=1

    except tf.errors.OutOfRangeError:#当读取完列队中所有数据时,抛出异常
        print('done!')
    finally:
        #Request that the threads stop.After this is called, calls to should_stop() will return True.
        coord.request_stop()
    coord.join(threads)

首先是一些参数的设置，然后通过get_files和get_batch建立等下需要运行的Graph。由于读取图片时，涉及到队列已经多线程，因此需要tf.train.Coordinator来产生一个线程协调者，主要作用是协调线程是否终止（This class implements a simple mechanism to coordinate the termination of a set of threads.）,更详细的用法可以参考下文的函数介绍和官网的说明。然后调用tf.train.start_queue_runners来启动之前定义好的Graph中所有的线程。

最后的效果：

函数注释：

1）np.hstack：

函数原型：numpy.hstack(tup)

tup可以是python中的元组（tuple）、列表（list），或者numpy中数组（array），函数作用是将tup在水平方向上（按列顺序）合并。

举例：

a=[1,2,3]

b=[4,5,6]

print(np.hstack((a,b)))

输出：[1 2 3 4 5 6 ]

2）transpose()

函数原型：numpy.transpose(a, axes=None)

作用：将输入的array转置，并返回转置后的array

举例：

>>> x = np.arange(4).reshape((2,2))

>>> x

array([[0, 1],

       [2, 3]])

>>> np.transpose(x)

array([[0, 2],

       [1, 3]])

注：

image_list = ["D:\\1.jpg","D:\\2.jpg","D:\\3.jpg"]
label_list = [1,0,1]

temp = np.array([image_list, label_list])
print(temp)
#输出：
#[['D:\\1.jpg' 'D:\\2.jpg' 'D:\\3.jpg']
# ['1' '0' '1']]

temp = temp.transpose()
print(temp)
#输出：
#[['D:\\1.jpg' '1']
# ['D:\\2.jpg' '0']
# ['D:\\3.jpg' '1']]
np.random.shuffle(temp)
print(temp)

#输出：
#[['D:\\2.jpg' '0']
# ['D:\\1.jpg' '1']
# ['D:\\3.jpg' '1']]

3）tf.cast

cast(
    x,
    dtype,
    name=None
)

将x转换为dtype数据类型的张量。

举例：

x = tf.constant([1.8, 2.2], dtype=tf.float32)

tf.cast(x, tf.int32)  # [1, 2], dtype=tf.int32

4）tf.train.slice_input_producer

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

Produces a slice of each Tensor in tensor_list.

Implemented using a Queue -- a QueueRunner for the Queue is
added to the current Graph's QUEUE_RUNNERcollection.

Args:

• tensor_list: A list of Tensor objects. Every Tensor in tensor_list must
  have the same size in the first dimension.
• 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.
• 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).

Returns:

A list of tensors, one for each element of tensor_list. If the tensor
in tensor_list has shape [N, a, b, .., z], then the
corresponding output tensor will have shape [a, b, ..., z].

Raises:

• ValueError: if slice_input_producer produces nothing from tensor_list.

简单说来，就是生成一个队列，该队列的容量为capacity。

5）tf.read_file

作用：读取输入文件的内容并输出

6）tf.image.decode_jpeg

作用：将JPEG格式编码的图片解码成uint8数据类型的tensor。

7）tf.image.resize_image_with_crop_or_pad

resize_image_with_crop_or_pad(
    image,
    target_height,
    target_width
)

将图片大小调整为target_height和target_width大小。若原图像比较大，则以中心点为裁剪。若原图像比较小，则在短边补零，使得大小为target_height和target_width。

8）tf.image.per_image_standardization

线性尺度变化，使得原图像具有零均值，单位范数（ zero mean and unit norm）。

也就是计算(x - mean) / adjusted_stddev，其中mean是图像中所有像素的平均值，adjusted_stddev = max(stddev, 1.0/sqrt(image.NumElements()))。

adjusted_stddev是图像中所有像素的标准差，max作用为防止stddev的值为0。

9）tf.train.batch

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
)

作用：Creates batches of tensors in tensors.即从输入的tensors获取batch_size大小的数据。

该函数是利用队列实现的。因此在使用的时候需要使用QueueRunner启动队列。

10）tf.train.Coordinator()

作用：线程协调者

任意一个线程可以调用coord.request_stop()来使所有线程停止。为了达到这一目的，每个线程必须定期检查coord.should_stop()。只要coord.request_stop()一被调用，那么coord.should_stop()马上返回True。

因此，一个典型的 thread running with a coordinator如下：

while not coord.should_stop():

  ...do some work...

11）tf.train.start_queue_runners

作用：启动graph中所有的队列。

说明：

代码来自：https://github.com/kevin28520/My-TensorFlow-tutorials，略有修改

函数作用主要参考tensorflow官网。https://www.tensorflow.org/versions/master/api_docs/

本文中修改后的代码可以在这里下载：https://github.com/hjl240/dog_vs_cat