tensorflow 实战猫狗大战（一）训练自己的数据

清疚 2022-06-04 02:59 235阅读 0赞

本文为参考[http://i.youku.com/deeplearning101 ][http_i.youku.com_deeplearning101]这位大神的视频所写的一些笔记

这是一个简单的二分类问题，目的就是区别猫和狗的图片，数据集在这链接：http://pan.baidu.com/s/1dFd8kmt 密码：psor

首先编写一个input\_data.py这个文件，目的就是返回

input\_data.py

**\[python\]**  view plain  copy

print ?

1.  \#coding=utf-8
2.  import tensorflow as tf
3.  import numpy as np
4.  import os
5.  
6.  
7.  \# file\_dir = '/home/hjxu/PycharmProjects/tf\_examples/dog\_cat/data/train/'
8.  
9.  \# 获取文件路径和标签
10. 
11. def get\_files(file\_dir):
12. \# file\_dir: 文件夹路径
13. \# return: 乱序后的图片和标签
14. 
15. cats = \[\]
16. label\_cats = \[\]
17. dogs = \[\]
18. label\_dogs = \[\]
19. \# 载入数据路径并写入标签值
20. for file in os.listdir(file\_dir):
21. name = file.split('.')
22. if name\[0\] == 'cat':
23. cats.append(file\_dir + file)
24. label\_cats.append(0)
25. else:
26. dogs.append(file\_dir + file)
27. label\_dogs.append(1)
28. print("There are %d cats\\nThere are %d dogs" % (len(cats), len(dogs)))
29. 
30. \# 打乱文件顺序
31. image\_list = np.hstack((cats, dogs))
32. label\_list = np.hstack((label\_cats, label\_dogs))
33. temp = np.array(\[image\_list, label\_list\])
34. temp = temp.transpose() \# 转置
35. np.random.shuffle(temp)
36. 
37. image\_list = list(temp\[:, 0\])
38. label\_list = list(temp\[:, 1\])
39. label\_list = \[int(i) for i in label\_list\]
40. 
41. return image\_list, label\_list
42. 
43. \# img\_list,label\_list = get\_files(file\_dir)
44. 
45. \# 生成相同大小的批次
46. def get\_batch(image, label, image\_W, image\_H, batch\_size, capacity):
47. \# image, label: 要生成batch的图像和标签list
48. \# image\_W, image\_H: 图片的宽高
49. \# batch\_size: 每个batch有多少张图片
50. \# capacity: 队列容量
51. \# return: 图像和标签的batch
52. 
53. \# 将python.list类型转换成tf能够识别的格式
54. image = tf.cast(image, tf.string)
55. label = tf.cast(label, tf.int32)
56. 
57. \# 生成队列
58. input\_queue = tf.train.slice\_input\_producer(\[image, label\])
59. 
60. image\_contents = tf.read\_file(input\_queue\[0\])
61. label = input\_queue\[1\]
62. image = tf.image.decode\_jpeg(image\_contents, channels=3)
63. 
64. \# 统一图片大小
65. \# 视频方法
66. \# image = tf.image.resize\_image\_with\_crop\_or\_pad(image, image\_W, image\_H)
67. \# 我的方法
68. image = tf.image.resize\_images(image, \[image\_H, image\_W\], method=tf.image.ResizeMethod.NEAREST\_NEIGHBOR)
69. image = tf.cast(image, tf.float32)
70. \# image = tf.image.per\_image\_standardization(image) \# 标准化数据
71. image\_batch, label\_batch = tf.train.batch(\[image, label\],
72. batch\_size=batch\_size,
73. num\_threads=64, \# 线程
74. capacity=capacity)
75. 
76. \# 这行多余？
77. \# label\_batch = tf.reshape(label\_batch, \[batch\_size\])
78. 
79. return image\_batch, label\_batch
80. 
81. 
82. \# import matplotlib.pyplot as plt
83. \#
84. \# BATCH\_SIZE = 2
85. \# CAPACITY = 256
86. \# IMG\_W = 208
87. \# IMG\_H = 208
88. \#
89. \#
90. \# image\_list, label\_list = get\_files(file\_dir)
91. \# image\_batch, label\_batch = get\_batch(image\_list, label\_list, IMG\_W, IMG\_H, BATCH\_SIZE, CAPACITY)
92. \#
93. \# with tf.Session() as sess:
94. \# i = 0
95. \# coord = tf.train.Coordinator()
96. \# threads = tf.train.start\_queue\_runners(coord=coord)
97. \# try:
98. \# while not coord.should\_stop() and i < 5:
99. \# img, label = sess.run(\[image\_batch, label\_batch\])
100. \#
101. \# for j in np.arange(BATCH\_SIZE):
102. \# print("label: %d" % label\[j\])
103. \# plt.imshow(img\[j, :, :, :\])
104. \# plt.show()
105. \# i += 1
106. \# except tf.errors.OutOfRangeError:
107. \# print("done!")
108. \# finally:
109. \# coord.request\_stop()
110. \# coord.join(threads)

#coding=utf-8
    import tensorflow as tf
    import numpy as np
    import os
    
    
    # file_dir = '/home/hjxu/PycharmProjects/tf_examples/dog_cat/data/train/'
    
    # 获取文件路径和标签
    
    def get_files(file_dir):
        # file_dir: 文件夹路径
        # return: 乱序后的图片和标签
    
        cats = []
        label_cats = []
        dogs = []
        label_dogs = []
        # 载入数据路径并写入标签值
        for file in os.listdir(file_dir):
            name = file.split('.')
            if name[0] == 'cat':
                cats.append(file_dir + file)
                label_cats.append(0)
            else:
                dogs.append(file_dir + file)
                label_dogs.append(1)
        print("There are %d cats\nThere are %d dogs" % (len(cats), len(dogs)))
    
        # 打乱文件顺序
        image_list = np.hstack((cats, dogs))
        label_list = np.hstack((label_cats, label_dogs))
        temp = np.array([image_list, label_list])
        temp = temp.transpose()     # 转置
        np.random.shuffle(temp)
    
        image_list = list(temp[:, 0])
        label_list = list(temp[:, 1])
        label_list = [int(i) for i in label_list]
    
        return image_list, label_list
    
    # img_list,label_list = get_files(file_dir)
    
    # 生成相同大小的批次
    def get_batch(image, label, image_W, image_H, batch_size, capacity):
        # image, label: 要生成batch的图像和标签list
        # image_W, image_H: 图片的宽高
        # batch_size: 每个batch有多少张图片
        # capacity: 队列容量
        # return: 图像和标签的batch
    
        # 将python.list类型转换成tf能够识别的格式
        image = tf.cast(image, tf.string)
        label = tf.cast(label, tf.int32)
    
        # 生成队列
        input_queue = tf.train.slice_input_producer([image, label])
    
        image_contents = tf.read_file(input_queue[0])
        label = input_queue[1]
        image = tf.image.decode_jpeg(image_contents, channels=3)
    
        # 统一图片大小
        # 视频方法
        # image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
        # 我的方法
        image = tf.image.resize_images(image, [image_H, image_W], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
        image = tf.cast(image, tf.float32)
        # image = tf.image.per_image_standardization(image)   # 标准化数据
        image_batch, label_batch = tf.train.batch([image, label],
                                                  batch_size=batch_size,
                                                  num_threads=64,   # 线程
                                                  capacity=capacity)
    
        # 这行多余？
        # label_batch = tf.reshape(label_batch, [batch_size])
    
        return image_batch, label_batch
    
    
    # import matplotlib.pyplot as plt
    #
    # BATCH_SIZE = 2
    # CAPACITY = 256
    # IMG_W = 208
    # IMG_H = 208
    #
    #
    # image_list, label_list = get_files(file_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:
    #         while not coord.should_stop() and i < 5:
    #             img, label = sess.run([image_batch, label_batch])
    #
    #             for j in np.arange(BATCH_SIZE):
    #                 print("label: %d" % label[j])
    #                 plt.imshow(img[j, :, :, :])
    #                 plt.show()
    #             i += 1
    #     except tf.errors.OutOfRangeError:
    #         print("done!")
    #     finally:
    #         coord.request_stop()
    #     coord.join(threads)

函数`get_files(file_dir)`的功能是获取给定路径`file_dir`下的所有的训练数据（包括图片和标签），以`list`的形式返回。  
　　由于训练数据前12500张是猫，后12500张是狗，如果直接按这个顺序训练，训练效果可能会受影响（我自己猜的），所以需要将顺序打乱，至于是读取数据的时候乱序还是训练的时候乱序可以自己选择（视频里说在这里乱序速度比较快）。因为图片和标签是一一对应的，所以要整合到一起乱序。  
　　这里先用`np.hstack()`方法将猫和狗图片和标签整合到一起，得到`image_list`和`label_list`，`hstack((a,b))`的功能是将a和b以水平的方式连接，比如原来`cats`和`dogs`是长度为12500的向量，执行了`hstack(cats, dogs)`后，`image_list`的长度为25000，同理`label_list`的长度也为25000。接着将一一对应的`image_list`和`label_list`再合并一次。`temp`的大小是2×25000，经过转置（变成25000×2），然后使用`np.random.shuffle()`方法进行乱序。  
　　最后从temp中分别取出乱序后的`image_list`和`label_list`列向量，作为函数的返回值。这里要注意，因为`label_list`里面的数据类型是字符串类型，所以加上`label_list = [int(i) for i in label_list]`这么一行将其转为int类型。

model.py

**\[python\]**  view plain  copy

print ?

1.  \#coding=utf-8
2.  import tensorflow as tf
3.  def inference(images, batch\_size, n\_classes):
4.  
5.  
6.  with tf.variable\_scope('conv1') as scope:
7.  weights = tf.get\_variable('weights',
8.  shape=\[3, 3, 3, 16\],
9.  dtype=tf.float32,
10. initializer=tf.truncated\_normal\_initializer(stddev=0.1, dtype=tf.float32))
11. biases = tf.get\_variable('biases',
12. shape=\[16\],
13. dtype=tf.float32,
14. initializer=tf.constant\_initializer(0.1))
15. conv = tf.nn.conv2d(images, weights, strides=\[1, 1, 1, 1\], padding='SAME')
16. pre\_activation = tf.nn.bias\_add(conv, biases)
17. conv1 = tf.nn.relu(pre\_activation, name=scope.name)
18. 
19. with tf.variable\_scope('pooling1\_lrn') as scope:
20. pool1 = tf.nn.max\_pool(conv1, ksize=\[1, 3, 3, 1\], strides=\[1, 2, 2, 1\], padding='SAME', name='pooling1')
21. norm1 = tf.nn.lrn(pool1, depth\_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')
22. 
23. with tf.variable\_scope('conv2') as scope:
24. weights = tf.get\_variable('weights',
25. shape=\[3, 3, 16, 16\],
26. dtype=tf.float32,
27. initializer=tf.truncated\_normal\_initializer(stddev=0.1, dtype=tf.float32))
28. biases = tf.get\_variable('biases',
29. shape=\[16\],
30. dtype=tf.float32,
31. initializer=tf.constant\_initializer(0.1))
32. conv = tf.nn.conv2d(norm1, weights, strides=\[1, 1, 1, 1\], padding='SAME')
33. pre\_activation = tf.nn.bias\_add(conv, biases)
34. conv2 = tf.nn.relu(pre\_activation, name='conv2')
35. 
36. \# pool2 and norm2
37. with tf.variable\_scope('pooling2\_lrn') as scope:
38. norm2 = tf.nn.lrn(conv2, depth\_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2')
39. pool2 = tf.nn.max\_pool(norm2, ksize=\[1, 3, 3, 1\], strides=\[1, 1, 1, 1\], padding='SAME', name='pooling2')
40. 
41. with tf.variable\_scope('local3') as scope:
42. reshape = tf.reshape(pool2, shape=\[batch\_size, -1\])
43. dim = reshape.get\_shape()\[1\].value
44. weights = tf.get\_variable('weights',
45. shape=\[dim, 128\],
46. dtype=tf.float32,
47. initializer=tf.truncated\_normal\_initializer(stddev=0.005, dtype=tf.float32))
48. biases = tf.get\_variable('biases',
49. shape=\[128\],
50. dtype=tf.float32,
51. initializer=tf.constant\_initializer(0.1))
52. local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
53. 
54. \# local4
55. with tf.variable\_scope('local4') as scope:
56. weights = tf.get\_variable('weights',
57. shape=\[128, 128\],
58. dtype=tf.float32,
59. initializer=tf.truncated\_normal\_initializer(stddev=0.005, dtype=tf.float32))
60. biases = tf.get\_variable('biases',
61. shape=\[128\],
62. dtype=tf.float32,
63. initializer=tf.constant\_initializer(0.1))
64. local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4')
65. 
66. \# softmax
67. with tf.variable\_scope('softmax\_linear') as scope:
68. weights = tf.get\_variable('softmax\_linear',
69. shape=\[128, n\_classes\],
70. dtype=tf.float32,
71. initializer=tf.truncated\_normal\_initializer(stddev=0.005, dtype=tf.float32))
72. biases = tf.get\_variable('biases',
73. shape=\[n\_classes\],
74. dtype=tf.float32,
75. initializer=tf.constant\_initializer(0.1))
76. softmax\_linear = tf.add(tf.matmul(local4, weights), biases, name='softmax\_linear')
77. 
78. return softmax\_linear
79. 
80. 
81. 
82. def losses(logits, labels):
83. with tf.variable\_scope('loss') as scope:
84. cross\_entropy = tf.nn.sparse\_softmax\_cross\_entropy\_with\_logits \\
85. (logits=logits, labels=labels, name='xentropy\_per\_example')
86. loss = tf.reduce\_mean(cross\_entropy, name='loss')
87. tf.summary.scalar(scope.name + '/loss', loss)
88. return loss
89. 
90. def trainning(loss, learning\_rate):
91. with tf.name\_scope('optimizer'):
92. optimizer = tf.train.AdamOptimizer(learning\_rate= learning\_rate)
93. global\_step = tf.Variable(0, name='global\_step', trainable=False)
94. train\_op = optimizer.minimize(loss, global\_step= global\_step)
95. return train\_op
96. 
97. def evaluation(logits, labels):
98. with tf.variable\_scope('accuracy') as scope:
99. correct = tf.nn.in\_top\_k(logits, labels, 1)
100. correct = tf.cast(correct, tf.float16)
101. accuracy = tf.reduce\_mean(correct)
102. tf.summary.scalar(scope.name + '/accuracy', accuracy)
103. return accuracy

#coding=utf-8
    import tensorflow as tf
    def inference(images, batch_size, n_classes):
    
    
        with tf.variable_scope('conv1') as scope:
            weights = tf.get_variable('weights',
                                      shape=[3, 3, 3, 16],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[16],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(images, weights, strides=[1, 1, 1, 1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            conv1 = tf.nn.relu(pre_activation, name=scope.name)
    
        with tf.variable_scope('pooling1_lrn') as scope:
                pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME', name='pooling1')
                norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm1')
    
        with tf.variable_scope('conv2') as scope:
                    weights = tf.get_variable('weights',
                                              shape=[3, 3, 16, 16],
                                              dtype=tf.float32,
                                              initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
                    biases = tf.get_variable('biases',
                                             shape=[16],
                                             dtype=tf.float32,
                                             initializer=tf.constant_initializer(0.1))
                    conv = tf.nn.conv2d(norm1, weights, strides=[1, 1, 1, 1], padding='SAME')
                    pre_activation = tf.nn.bias_add(conv, biases)
                    conv2 = tf.nn.relu(pre_activation, name='conv2')
    
        # pool2 and norm2
        with tf.variable_scope('pooling2_lrn') as scope:
            norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name='norm2')
            pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding='SAME', name='pooling2')
    
        with tf.variable_scope('local3') as scope:
            reshape = tf.reshape(pool2, shape=[batch_size, -1])
            dim = reshape.get_shape()[1].value
            weights = tf.get_variable('weights',
                                      shape=[dim, 128],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[128],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
        local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
    
        # local4
        with tf.variable_scope('local4') as scope:
            weights = tf.get_variable('weights',
                                      shape=[128, 128],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[128],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4')
    
        # softmax
        with tf.variable_scope('softmax_linear') as scope:
            weights = tf.get_variable('softmax_linear',
                                      shape=[128, n_classes],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[n_classes],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            softmax_linear = tf.add(tf.matmul(local4, weights), biases, name='softmax_linear')
    
        return softmax_linear
    
    
    
    def losses(logits, labels):
        with tf.variable_scope('loss') as scope:
            cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits \
                (logits=logits, labels=labels, name='xentropy_per_example')
            loss = tf.reduce_mean(cross_entropy, name='loss')
            tf.summary.scalar(scope.name + '/loss', loss)
        return loss
    
    def trainning(loss, learning_rate):
        with tf.name_scope('optimizer'):
            optimizer = tf.train.AdamOptimizer(learning_rate= learning_rate)
            global_step = tf.Variable(0, name='global_step', trainable=False)
            train_op = optimizer.minimize(loss, global_step= global_step)
        return train_op
    
    def evaluation(logits, labels):
        with tf.variable_scope('accuracy') as scope:
            correct = tf.nn.in_top_k(logits, labels, 1)
            correct = tf.cast(correct, tf.float16)
            accuracy = tf.reduce_mean(correct)
            tf.summary.scalar(scope.name + '/accuracy', accuracy)
        return accuracy

函数`get_batch()`用于将图片分批次，因为一次性将所有25000张图片载入内存不现实也不必要，所以将图片分成不同批次进行训练。这里传入的`image`和`label`参数就是函数`get_files()`返回的`image_list`和`label_list`，是[Python][]中的list类型，所以需要将其转为TensorFlow可以识别的`tensor`格式。  
　　这里使用队列来获取数据，因为队列操作牵扯到线程，我自己对这块也不懂，，所以只从大体上理解了一下，想要系统学习可以去[官方文档][Link 1]看看，这里引用了一张图解释。  
　　  
![队列][IncremeterFifoQueue.gif]

我认为大体上可以这么理解：每次训练时，从队列中取一个batch送到网络进行训练，然后又有新的图片从训练库中注入队列，这样循环往复。队列相当于起到了训练库到网络模型间数据管道的作用，训练数据通过队列送入网络。（我也不确定这么理解对不对，欢迎指正）

继续看程序，我们使用`slice_input_producer()`来建立一个队列，将`image`和`label`放入一个list中当做参数传给该函数。然后从队列中取得`image`和`label`，要注意，用`read_file()`读取图片之后，要按照图片格式进行解码。本例程中训练数据是jpg格式的，所以使用`decode_jpeg()`解码器，如果是其他格式，就要用其他解码器，具体可以从官方API中查询。注意decode出来的数据类型是`uint8`，之后模型卷积层里面`conv2d()`要求输入数据为`float32`类型，所以如果删掉标准化步骤之后需要进行类型转换。

因为训练库中图片大小是不一样的，所以还需要将图片裁剪成相同大小(`img_W`和`img_H`)。视频中是用`resize_image_with_crop_or_pad()`方法来裁剪图片，这种方法是从图像中心向四周裁剪，如果图片超过规定尺寸，最后只会剩中间区域的一部分，可能一只狗只剩下躯干，头都不见了，用这样的图片训练结果肯定会受到影响。所以这里我稍微改动了一下，使用`resize_images()`对图像进行缩放，而不是裁剪，采用`NEAREST_NEIGHBOR`插值方法（其他几种插值方法出来的结果图像是花的，具体原因不知道）。

缩放之后视频中还进行了`per_image_standardization (标准化)`步骤，但加了这步之后，得到的图片是花的，虽然各个通道单独提出来是正常的，三通道一起就不对了，删了标准化这步结果正常，所以这里把标准化步骤注释掉了。

然后用`tf.train.batch()`方法获取batch，还有一种方法是`tf.train.shuffle_batch()`，因为之前我们已经乱序过了，这里用普通的`batch()`就好。视频中获取batch后还对label进行了一下reshape()操作，在我看来这步是多余的，从`batch()`方法中获取的大小已经符合我们的要求了，注释掉也没什么影响，能正常获取图片。

最后将得到的`image_batch`和`label_batch`返回。`image_batch`是一个4D的tensor，\[batch, width, height, channels\]，`label_batch`是一个1D的tensor，\[batch\]。

可以用下面的代码测试获取图片是否成功，因为之前将图片转为float32了，因此这里imshow()出来的图片色彩会有点奇怪，因为本来imshow()是显示uint8类型的数据（灰度值在uint8类型下是0~255，转为float32后会超出这个范围，所以色彩有点奇怪），不过这不影响后面模型的训练。

training.py

**\[python\]**  view plain  copy

print ?

1.  \#coding=utf-8
2.  import os
3.  import numpy as np
4.  import tensorflow as tf
5.  import input\_data
6.  import model
7.  
8.  N\_CLASSES = 2 \#猫和狗
9.  IMG\_W = 208 \# resize图像，太大的话训练时间久
10. IMG\_H = 208
11. BATCH\_SIZE = 16
12. CAPACITY = 2000
13. MAX\_STEP = 10000 \# 一般大于10K
14. learning\_rate = 0.0001 \# 一般小于0.0001
15. 
16. train\_dir = '/home/hjxu/PycharmProjects/tf\_examples/dog\_cat/data/train/'
17. logs\_train\_dir = '/home/hjxu/PycharmProjects/tf\_examples/dog\_cat/log/train/'
18. 
19. train, train\_label = input\_data.get\_files(train\_dir)
20. train\_batch,train\_label\_batch=input\_data.get\_batch(train,
21. train\_label,
22. IMG\_W,
23. IMG\_H,
24. BATCH\_SIZE,
25. CAPACITY)
26. train\_logits = model.inference(train\_batch, BATCH\_SIZE, N\_CLASSES)
27. train\_loss = model.losses(train\_logits, train\_label\_batch)
28. train\_op = model.trainning(train\_loss, learning\_rate)
29. train\_\_acc = model.evaluation(train\_logits, train\_label\_batch)
30. summary\_op = tf.summary.merge\_all() \#这个是log汇总记录
31. 
32. \#产生一个会话
33. sess = tf.Session()
34. \#产生一个writer来写log文件
35. train\_writer = tf.summary.FileWriter(logs\_train\_dir, sess.graph)
36. \#产生一个saver来存储训练好的模型
37. saver = tf.train.Saver()
38. \#所有节点初始化
39. sess.run(tf.global\_variables\_initializer())
40. 
41. \#队列监控
42. coord = tf.train.Coordinator()
43. threads = tf.train.start\_queue\_runners(sess=sess, coord=coord)
44. 
45. try:
46. \#执行MAX\_STEP步的训练，一步一个batch
47. for step in np.arange(MAX\_STEP):
48. if coord.should\_stop():
49. break
50. \#启动以下操作节点，有个疑问，为什么train\_logits在这里没有开启？
51. \_, tra\_loss, tra\_acc = sess.run(\[train\_op, train\_loss, train\_\_acc\])
52. \#每隔50步打印一次当前的loss以及acc，同时记录log，写入writer
53. if step % 50 == 0:
54. print('Step %d, train loss = %.2f, train accuracy = %.2f%%' %(step, tra\_loss, tra\_acc\*100.0))
55. summary\_str = sess.run(summary\_op)
56. train\_writer.add\_summary(summary\_str, step)
57. \#每隔2000步，保存一次训练好的模型
58. if step % 2000 == 0 or (step + 1) == MAX\_STEP:
59. checkpoint\_path = os.path.join(logs\_train\_dir, 'model.ckpt')
60. saver.save(sess, checkpoint\_path, global\_step=step)
61. 
62. except tf.errors.OutOfRangeError:
63. print('Done training -- epoch limit reached')
64. finally:
65. coord.request\_stop()

#coding=utf-8
    import os
    import numpy as np
    import tensorflow as tf
    import input_data
    import model
    
    N_CLASSES = 2 #猫和狗
    IMG_W = 208  # resize图像，太大的话训练时间久
    IMG_H = 208
    BATCH_SIZE = 16
    CAPACITY = 2000
    MAX_STEP = 10000 # 一般大于10K
    learning_rate = 0.0001 # 一般小于0.0001
    
    train_dir = '/home/hjxu/PycharmProjects/tf_examples/dog_cat/data/train/'
    logs_train_dir = '/home/hjxu/PycharmProjects/tf_examples/dog_cat/log/train/'
    
    train, train_label = input_data.get_files(train_dir)
    train_batch,train_label_batch=input_data.get_batch(train,
                                    train_label,
                                    IMG_W,
                                    IMG_H,
                                    BATCH_SIZE,
                                    CAPACITY)
    train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
    train_loss = model.losses(train_logits, train_label_batch)
    train_op = model.trainning(train_loss, learning_rate)
    train__acc = model.evaluation(train_logits, train_label_batch)
    summary_op = tf.summary.merge_all() #这个是log汇总记录
    
    #产生一个会话
    sess = tf.Session()
    #产生一个writer来写log文件
    train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
     #产生一个saver来存储训练好的模型
    saver = tf.train.Saver()
    #所有节点初始化
    sess.run(tf.global_variables_initializer())
    
    #队列监控
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    
    try:
        #执行MAX_STEP步的训练，一步一个batch
        for step in np.arange(MAX_STEP):
            if coord.should_stop():
                    break
            #启动以下操作节点，有个疑问，为什么train_logits在这里没有开启？
            _, tra_loss, tra_acc = sess.run([train_op, train_loss, train__acc])
            #每隔50步打印一次当前的loss以及acc，同时记录log，写入writer
            if step % 50 == 0:
                print('Step %d, train loss = %.2f, train accuracy = %.2f%%' %(step, tra_loss, tra_acc*100.0))
                summary_str = sess.run(summary_op)
                train_writer.add_summary(summary_str, step)
            #每隔2000步，保存一次训练好的模型
            if step % 2000 == 0 or (step + 1) == MAX_STEP:
                checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
                saver.save(sess, checkpoint_path, global_step=step)
    
    except tf.errors.OutOfRangeError:
        print('Done training -- epoch limit reached')
    finally:
        coord.request_stop()

这时候会在logs文件夹生产一些文件，我们可以用tensorboard来显示，下一篇博客记下tensorboard的简单使用

参考博客[http://blog.csdn.net/qq\_16137569/article/details/72802387][http_blog.csdn.net_qq_16137569_article_details_72802387]

[http://blog.csdn.net/xinyu3307/article/details/74943033][http_blog.csdn.net_xinyu3307_article_details_74943033]

[http_i.youku.com_deeplearning101]: http://i.youku.com/deeplearning101
[Python]: http://lib.csdn.net/base/python
[Link 1]: http://wiki.jikexueyuan.com/project/tensorflow-zh/how_tos/threading_and_queues.html
[IncremeterFifoQueue.gif]: /images/20220604/bdd198c2950b4a4280c6a1825d7bc654.png
[http_blog.csdn.net_qq_16137569_article_details_72802387]: http://blog.csdn.net/qq_16137569/article/details/72802387
[http_blog.csdn.net_xinyu3307_article_details_74943033]: http://blog.csdn.net/xinyu3307/article/details/74943033