devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

18.1:tensorflow分类模型mobilenetv2训练(数据增强,保存模型,衰减学习率,tensorboard)，预测图像(单张,批量预测)，导出为pb完整示例_使用的算法为mobilenetv2的模型怎么保存

作者：你好赵伟 | 2024-06-04 17:43:18

赞

踩

使用的算法为mobilenetv2的模型怎么保存

    从前有个小孩子在学习tensorflow，于是他买了几本tensorflow书籍，他发现各种书籍里面讲的示例都是使用mnist数据集。由于框架已经封装好了，在使用数据时用一条命令就可以加载数据了，他也不知道这些数据是怎么被读取的。于是乎，他在训练自己的模型时碰到的数据都是一张张图像，仍然无从下手（一脸懵逼）。除此之外，他还想加一些其他功能，如怎么动态调节学习率，怎么使用tensorboard查看loss, accuracy, learningrate的变化，怎么显示训练过程中的图像，怎么可视化模型的结构，怎么保存模型。后来他把这些问题搞定了，但是他并不满足，他还想使用保存的模型(model.ckpt)对每张新的图像进行预测，后来发现自己需要预测的图像太多了，比较耗时，然后他想能不能使用批量数据一次输入多个同时预测。最后他还发现使用训练好的模型进行预测时还得重新定义网络结构(虽然也可使用.meta不用重新定义网络结构，但是这种方法每次必须输入一个批次数据)，于是后来发现了可以使用保存的模型生成一个pb文件，调用pb文件时只需指定输入，输出节点而无需重新定义网络结构就可以预测图像。再后来他使用模型预测新图像时发现所有图像都预测为同一类，经过分析他发现在使用batch normal时出现了问题，因为bn层在训练时和测试时不一样。。。

一 、训练

1. 数据集，批量数据的读取，数据增强

    他使用的是自己的.jpg数据，不过和flower data的结构一样(http://download.tensorflow.org/example_images/flower_photos.tgz)，一个大文件夹下分为各个小文件夹(flow photos的文件夹内有一个readme文件，得把它删掉)，每个小文件夹名字为该图像的标签，小文件夹内是该类图像。在训练模型时他想到的第一件事是获取这些图像的路径及对应标签吧，因此他写了个函数，该函数可以返回所有图像的路径及标签(标签是各个小文件夹的名字)：

  1. def get_files(file_dir):
  2.     image_list, label_list = [], []
  3.     for label in os.listdir(file_dir):
  4.         for img in glob.glob(os.path.join(file_dir, label, "*.jpg")):
  5.             image_list.append(img)
  6.             label_list.append(int(label_dict[label]))
  7.     print('There are %d data' %(len(image_list)))
  8.     temp = np.array([image_list, label_list])
  9.     temp = temp.transpose()
  10.     np.random.shuffle(temp)
  11.     image_list = list(temp[:, 0])
  12.     label_list = list(temp[:, 1])
  13.     label_list = [int(i) for i in label_list]
  14.     return image_list, label_list

他发现数据集的标签都是一个字符串，在模型训练时label需要为0,1,2,3,4...的整数，因此他自己对标签及label做了一个映射。

他建立了一个label.txt，里面为每一行为一个标签对映射，分别为：daisy:0, dandelion:1, roses:2, sunflowers:3, tulips:4。为了把标签和label对应起来他写了这几行代码：

  1. label_dict, label_dict_res = {}, {}
  2. # 手动指定一个从类别到label的映射关系
  3. with open("label.txt", 'r') as f:
  4.     for line in f.readlines():
  5.         folder, label = line.strip().split(':')[0], line.strip().split(':')[1]
  6.         label_dict[folder] = label
  7.         label_dict_res[label] = folder
  8. print(label_dict)

他之前使用过caffe，他知道caffe可以直接读取图像也可以把图像转为lmbd再读。他发现tensorfow得先把数据转为tf-record文件再读取，他嫌先转文件格式这种方法有点麻烦(虽然在训练速度上和消耗资源上有优势)，也想直接读取图像进行训练，于是后来他发现了tf.train.batch这个函数能解决这个问题。此外，他的数据不是很多，还想再对数据随机做一些变换来进行数据增强，后来他发了tf.image.random_flip_left_righ，tf.image.random_flip_up_down, tf.image.random_brightness, tf.image.random_contrast, tf.image.random_hue, tf.image.random_saturation这些函数。他还想用tensorboard查看训练过程中通过数据增强的图像是怎样的，于是他发现了tf.summary.image这个函数。最后他定义了获取批量数据的函数：

  1. def get_batch(image, label, image_W, image_H, batch_size, capacity):
  2.     image = tf.cast(image, tf.string)
  3.     label = tf.cast(label, tf.int32)
  4.     # make an input queue
  5.     input_queue = tf.train.slice_input_producer([image, label], shuffle=False)
  6.     label = input_queue[1]
  7.     image_contents = tf.read_file(input_queue[0])
  8.     image = tf.image.decode_jpeg(image_contents, channels=3)
  9.     # 数据增强
  10.     #image = tf.image.resize_image_with_pad(image, target_height=image_W, target_width=image_H)
  11.     image = tf.image.resize_images(image, (image_W, image_H))
  12.     # 随机左右翻转
  13.     image = tf.image.random_flip_left_right(image)
  14.     # 随机上下翻转
  15.     image = tf.image.random_flip_up_down(image)
  16.     # 随机设置图片的亮度
  17.     image = tf.image.random_brightness(image, max_delta=32/255.0)
  18.     # 随机设置图片的对比度
  19.     #image = tf.image.random_contrast(image, lower=0.5, upper=1.5)
  20.     # 随机设置图片的色度
  21.     image = tf.image.random_hue(image, max_delta=0.05)
  22.     # 随机设置图片的饱和度
  23.     #image = tf.image.random_saturation(image, lower=0.5, upper=1.5)
  24.     # 标准化,使图片的均值为0，方差为1
  25.     image = tf.image.per_image_standardization(image)
  26.     image_batch, label_batch = tf.train.batch([image, label],
  27.                                                 batch_size= batch_size,
  28.                                                 num_threads= 64,
  29.                                                 capacity = capacity)
  30.     tf.summary.image("input_img", image_batch, max_outputs=5)
  31.     label_batch = tf.reshape(label_batch, [batch_size])
  32.     image_batch = tf.cast(image_batch, tf.float32)
  33.     return image_batch, label_batch

2. mobilenetv2网络

    他在网上找到了一个mobilenetv2的网络，并建立了一个新的model.py文件，把该网络粘贴进去了（名字为class MobileNetV2）。这里他只是用了mobilenetv2，他也可以在网上找一个其他网络(resnet, vgg, inception, shufflenet...)前向传播的代码粘贴到这里，就可以训练其他的网络了。

  1. #coding:utf-8
  2.  
  3. import tensorflow as tf
  4. import tensorflow.contrib.slim as slim
  5. from tensorflow.contrib.layers.python.layers import batch_norm
  6. import tensorflow as tf
  7.  
  8.  
  9. import tensorflow as tf
  10. import tensorflow.contrib as tc
  11.  
  12. import numpy as np
  13. import time
  14.  
  15. class MobileNetV1(object):
  16.     def __init__(self, is_training=True, input_size=224):
  17.         self.input_size = input_size
  18.         self.is_training = is_training
  19.         self.normalizer = tc.layers.batch_norm
  20.         self.bn_params = {'is_training': self.is_training}
  21.  
  22.         with tf.variable_scope('MobileNetV1'):
  23.             self._create_placeholders()
  24.             self._build_model()
  25.  
  26.     def _create_placeholders(self):
  27.         self.input = tf.placeholder(dtype=tf.float32, shape=[None, self.input_size, self.input_size, 3])
  28.  
  29.     def _build_model(self):
  30.         i = 0
  31.         with tf.variable_scope('init_conv'):
  32.             self.conv1 = tc.layers.conv2d(self.input, num_outputs=32, kernel_size=3, stride=2,
  33.                                            normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  34.         # 1
  35.         with tf.variable_scope('dconv_block{}'.format(i)):
  36.             i += 1
  37.             self.dconv1 = tc.layers.separable_conv2d(self.conv1, num_outputs=None, kernel_size=3, depth_multiplier=1,
  38.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  39.             self.pconv1 = tc.layers.conv2d(self.dconv1, 64, 1, normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  40.         # 2
  41.         with tf.variable_scope('dconv_block{}'.format(i)):
  42.             i += 1
  43.             self.dconv2 = tc.layers.separable_conv2d(self.pconv1, None, 3, 1, 2,
  44.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  45.             self.pconv2 = tc.layers.conv2d(self.dconv2, 128, 1, normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  46.         # 3
  47.         with tf.variable_scope('dconv_block{}'.format(i)):
  48.             i += 1
  49.             self.dconv3 = tc.layers.separable_conv2d(self.pconv2, None, 3, 1, 1,
  50.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  51.             self.pconv3 = tc.layers.conv2d(self.dconv3, 128, 1, normalizer_fn=self.normalizer,
  52.                                            normalizer_params=self.bn_params)
  53.         # 4
  54.         with tf.variable_scope('dconv_block{}'.format(i)):
  55.             i += 1
  56.             self.dconv4 = tc.layers.separable_conv2d(self.pconv3, None, 3, 1, 2,
  57.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  58.             self.pconv4 = tc.layers.conv2d(self.dconv4, 256, 1, normalizer_fn=self.normalizer,
  59.                                            normalizer_params=self.bn_params)
  60.         # 5
  61.         with tf.variable_scope('dconv_block{}'.format(i)):
  62.             i += 1
  63.             self.dconv5 = tc.layers.separable_conv2d(self.pconv4, None, 3, 1, 1,
  64.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  65.             self.pconv5 = tc.layers.conv2d(self.dconv5, 256, 1, normalizer_fn=self.normalizer,
  66.                                            normalizer_params=self.bn_params)
  67.         # 6
  68.         with tf.variable_scope('dconv_block{}'.format(i)):
  69.             i += 1
  70.             self.dconv6 = tc.layers.separable_conv2d(self.pconv5, None, 3, 1, 2,
  71.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  72.             self.pconv6 = tc.layers.conv2d(self.dconv6, 512, 1, normalizer_fn=self.normalizer,
  73.                                            normalizer_params=self.bn_params)
  74.         # 7_1
  75.         with tf.variable_scope('dconv_block{}'.format(i)):
  76.             i += 1
  77.             self.dconv71 = tc.layers.separable_conv2d(self.pconv6, None, 3, 1, 1,
  78.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  79.             self.pconv71 = tc.layers.conv2d(self.dconv71, 512, 1, normalizer_fn=self.normalizer,
  80.                                            normalizer_params=self.bn_params)
  81.         # 7_2
  82.         with tf.variable_scope('dconv_block{}'.format(i)):
  83.             i += 1
  84.             self.dconv72 = tc.layers.separable_conv2d(self.pconv71, None, 3, 1, 1,
  85.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  86.             self.pconv72 = tc.layers.conv2d(self.dconv72, 512, 1, normalizer_fn=self.normalizer,
  87.                                            normalizer_params=self.bn_params)
  88.         # 7_3
  89.         with tf.variable_scope('dconv_block{}'.format(i)):
  90.             i += 1
  91.             self.dconv73 = tc.layers.separable_conv2d(self.pconv72, None, 3, 1, 1,
  92.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  93.             self.pconv73 = tc.layers.conv2d(self.dconv73, 512, 1, normalizer_fn=self.normalizer,
  94.                                            normalizer_params=self.bn_params)
  95.         # 7_4
  96.         with tf.variable_scope('dconv_block{}'.format(i)):
  97.             i += 1
  98.             self.dconv74 = tc.layers.separable_conv2d(self.pconv73, None, 3, 1, 1,
  99.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  100.             self.pconv74 = tc.layers.conv2d(self.dconv74, 512, 1, normalizer_fn=self.normalizer,
  101.                                            normalizer_params=self.bn_params)
  102.         # 7_5
  103.         with tf.variable_scope('dconv_block{}'.format(i)):
  104.             i += 1
  105.             self.dconv75 = tc.layers.separable_conv2d(self.pconv74, None, 3, 1, 1,
  106.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  107.             self.pconv75 = tc.layers.conv2d(self.dconv75, 512, 1, normalizer_fn=self.normalizer,
  108.                                            normalizer_params=self.bn_params)
  109.         # 8
  110.         with tf.variable_scope('dconv_block{}'.format(i)):
  111.             i += 1
  112.             self.dconv8 = tc.layers.separable_conv2d(self.pconv75, None, 3, 1, 2,
  113.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  114.             self.pconv8 = tc.layers.conv2d(self.dconv8, 1024, 1, normalizer_fn=self.normalizer,
  115.                                            normalizer_params=self.bn_params)
  116.         # 9
  117.         with tf.variable_scope('dconv_block{}'.format(i)):
  118.             i += 1
  119.             self.dconv9 = tc.layers.separable_conv2d(self.pconv8, None, 3, 1, 1,
  120.                                                      normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  121.             self.pconv9 = tc.layers.conv2d(self.dconv9, 1024, 1, normalizer_fn=self.normalizer,
  122.                                            normalizer_params=self.bn_params)
  123.         with tf.variable_scope('global_max_pooling'):
  124.             self.pool = tc.layers.max_pool2d(self.pconv9, kernel_size=7, stride=1)
  125.         with tf.variable_scope('prediction'):
  126.             self.output = tc.layers.conv2d(self.pool, 1000, 1, activation_fn=None)
  127.  
  128.  
  129. class MobileNetV2(object):
  130.     def __init__(self, input, num_classes=1000, is_training=True):
  131.         self.input = input
  132.         self.num_classes = num_classes
  133.         self.is_training = is_training
  134.         self.normalizer = tc.layers.batch_norm
  135.         self.bn_params = {'is_training': self.is_training}
  136.  
  137.         with tf.variable_scope('MobileNetV2'):
  138.             self._build_model()
  139.  
  140.     def _build_model(self):
  141.         self.i = 0
  142.         with tf.variable_scope('init_conv'):
  143.             output = tc.layers.conv2d(self.input, 32, 3, 2,
  144.                                       normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  145.             # print(output.get_shape())
  146.         self.output = self._inverted_bottleneck(output, 1, 16, 0)
  147.         self.output = self._inverted_bottleneck(self.output, 6, 24, 1)
  148.         self.output = self._inverted_bottleneck(self.output, 6, 24, 0)
  149.         self.output = self._inverted_bottleneck(self.output, 6, 32, 1)
  150.         self.output = self._inverted_bottleneck(self.output, 6, 32, 0)
  151.         self.output = self._inverted_bottleneck(self.output, 6, 32, 0)
  152.         self.output = self._inverted_bottleneck(self.output, 6, 64, 1)
  153.         self.output = self._inverted_bottleneck(self.output, 6, 64, 0)
  154.         self.output = self._inverted_bottleneck(self.output, 6, 64, 0)
  155.         self.output = self._inverted_bottleneck(self.output, 6, 64, 0)
  156.         self.output = self._inverted_bottleneck(self.output, 6, 96, 0)
  157.         self.output = self._inverted_bottleneck(self.output, 6, 96, 0)
  158.         self.output = self._inverted_bottleneck(self.output, 6, 96, 0)
  159.         self.output = self._inverted_bottleneck(self.output, 6, 160, 1)
  160.         self.output = self._inverted_bottleneck(self.output, 6, 160, 0)
  161.         self.output = self._inverted_bottleneck(self.output, 6, 160, 0)
  162.         self.output = self._inverted_bottleneck(self.output, 6, 320, 0)
  163.         self.output = tc.layers.conv2d(self.output, 1280, 1, normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  164.         self.output = tc.layers.avg_pool2d(self.output, 7)
  165.         self.output = tc.layers.conv2d(self.output, self.num_classes, 1, activation_fn=None)
  166.         self.output = tf.reshape(self.output, shape=[-1, self.num_classes], name="logit")
  167.  
  168.  
  169.     def _inverted_bottleneck(self, input, up_sample_rate, channels, subsample):
  170.         with tf.variable_scope('inverted_bottleneck{}_{}_{}'.format(self.i, up_sample_rate, subsample)):
  171.             self.i += 1
  172.             stride = 2 if subsample else 1
  173.             output = tc.layers.conv2d(input, up_sample_rate*input.get_shape().as_list()[-1], 1,
  174.                                       activation_fn=tf.nn.relu6,
  175.                                       normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  176.             output = tc.layers.separable_conv2d(output, None, 3, 1, stride=stride,
  177.                                                 activation_fn=tf.nn.relu6,
  178.                                                 normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  179.             output = tc.layers.conv2d(output, channels, 1, activation_fn=None,
  180.                                       normalizer_fn=self.normalizer, normalizer_params=self.bn_params)
  181.             if input.get_shape().as_list()[-1] == channels:
  182.                 output = tf.add(input, output)
  183.             return output
  184.  
  185.  
  186. # small inception
  187. def model4(x, N_CLASSES, is_trian = False):
  188.     x = tf.contrib.layers.conv2d(x, 64, [5, 5], 1, 'SAME', activation_fn=tf.nn.relu)
  189.     x = batch_norm(x, decay=0.9, updates_collections=None, is_training=is_trian)  # 训练阶段is_trainging设置为true,训练完毕后使用模型时设置为false
  190.     x = tf.contrib.layers.max_pool2d(x, [2, 2], stride=2, padding='SAME')
  191.  
  192.     x1_1 = tf.contrib.layers.conv2d(x, 64, [1, 1], 1, 'SAME', activation_fn=tf.nn.relu)  # 1X1 核
  193.     x1_1 = batch_norm(x1_1, decay=0.9, updates_collections=None, is_training=is_trian)
  194.     x3_3 = tf.contrib.layers.conv2d(x, 64, [3, 3], 1, 'SAME', activation_fn=tf.nn.relu)  # 3x3 核
  195.     x3_3 = batch_norm(x3_3, decay=0.9, updates_collections=None, is_training=is_trian)
  196.     x5_5 = tf.contrib.layers.conv2d(x, 64, [5, 5], 1, 'SAME', activation_fn=tf.nn.relu)  # 5x5 核
  197.     x5_5 = batch_norm(x5_5, decay=0.9, updates_collections=None, is_training=is_trian)
  198.     x = tf.concat([x1_1, x3_3, x5_5], axis=-1)  # 连接在一起，得到64*3=192个通道
  199.     x = tf.contrib.layers.max_pool2d(x, [2, 2], stride=2, padding='SAME')
  200.  
  201.     x1_1 = tf.contrib.layers.conv2d(x, 128, [1, 1], 1, 'SAME', activation_fn=tf.nn.relu)
  202.     x1_1 = batch_norm(x1_1, decay=0.9, updates_collections=None, is_training=is_trian)
  203.     x3_3 = tf.contrib.layers.conv2d(x, 128, [3, 3], 1, 'SAME', activation_fn=tf.nn.relu)
  204.     x3_3 = batch_norm(x3_3, decay=0.9, updates_collections=None, is_training=is_trian)
  205.     x5_5 = tf.contrib.layers.conv2d(x, 128, [5, 5], 1, 'SAME', activation_fn=tf.nn.relu)
  206.     x5_5 = batch_norm(x5_5, decay=0.9, updates_collections=None, is_training=is_trian)
  207.     x = tf.concat([x1_1, x3_3, x5_5], axis=-1)
  208.     x = tf.contrib.layers.max_pool2d(x, [2, 2], stride=2, padding='SAME')
  209.  
  210.     shp = x.get_shape()
  211.     x = tf.reshape(x, [-1, shp[1]*shp[2]*shp[3]])  # flatten
  212.     logits = tf.contrib.layers.fully_connected(x, N_CLASSES, activation_fn=None)  # output logist without softmax
  213.     return logits
  214.  
  215.  
  216. # 2conv + 3fc
  217. def model2(images, batch_size, n_classes):
  218.     '''Build the model
  219.     Args:
  220.         images: image batch, 4D tensor, tf.float32, [batch_size, width, height, channels]
  221.     Returns:
  222.         output tensor with the computed logits, float, [batch_size, n_classes]
  223.     '''
  224.     #conv1, shape = [kernel size, kernel size, channels, kernel numbers]
  225.     
  226.     with tf.variable_scope('conv1') as scope:
  227.         weights = tf.get_variable('weights', 
  228.                                   shape = [3,3,3, 16],
  229.                                   dtype = tf.float32, 
  230.                                   initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
  231.         biases = tf.get_variable('biases', 
  232.                                  shape=[16],
  233.                                  dtype=tf.float32,
  234.                                  initializer=tf.constant_initializer(0.1))
  235.         conv = tf.nn.conv2d(images, weights, strides=[1,1,1,1], padding='SAME')
  236.         pre_activation = tf.nn.bias_add(conv, biases)
  237.         conv1 = tf.nn.relu(pre_activation, name= scope.name)
  238.     
  239.     #pool1 and norm1   
  240.     with tf.variable_scope('pooling1_lrn') as scope:
  241.         pool1 = tf.nn.max_pool(conv1, ksize=[1,3,3,1],strides=[1,2,2,1],
  242.                                padding='SAME', name='pooling1')
  243.         norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001/9.0,
  244.                           beta=0.75,name='norm1')
  245.     
  246.     #conv2
  247.     with tf.variable_scope('conv2') as scope:
  248.         weights = tf.get_variable('weights',
  249.                                   shape=[3,3,16,16],
  250.                                   dtype=tf.float32,
  251.                                   initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
  252.         biases = tf.get_variable('biases',
  253.                                  shape=[16], 
  254.                                  dtype=tf.float32,
  255.                                  initializer=tf.constant_initializer(0.1))
  256.         conv = tf.nn.conv2d(norm1, weights, strides=[1,1,1,1],padding='SAME')
  257.         pre_activation = tf.nn.bias_add(conv, biases)
  258.         conv2 = tf.nn.relu(pre_activation, name='conv2')
  259.     
  260.     
  261.     #pool2 and norm2
  262.     with tf.variable_scope('pooling2_lrn') as scope:
  263.         norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
  264.                           beta=0.75,name='norm2')
  265.         pool2 = tf.nn.max_pool(norm2, ksize=[1,3,3,1], strides=[1,1,1,1],
  266.                                padding='SAME',name='pooling2')
  267.     
  268.     
  269.     #local3
  270.     with tf.variable_scope('local3') as scope:
  271.         reshape = tf.reshape(pool2, shape=[batch_size, -1])
  272.         dim = reshape.get_shape()[1].value
  273.         weights = tf.get_variable('weights',
  274.                                   shape=[dim,128],
  275.                                   dtype=tf.float32,
  276.                                   initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
  277.         biases = tf.get_variable('biases',
  278.                                  shape=[128],
  279.                                  dtype=tf.float32, 
  280.                                  initializer=tf.constant_initializer(0.1))
  281.         local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)    
  282.     
  283.     #local4
  284.     with tf.variable_scope('local4') as scope:
  285.         weights = tf.get_variable('weights',
  286.                                   shape=[128,128],
  287.                                   dtype=tf.float32, 
  288.                                   initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
  289.         biases = tf.get_variable('biases',
  290.                                  shape=[128],
  291.                                  dtype=tf.float32,
  292.                                  initializer=tf.constant_initializer(0.1))
  293.         local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4')
  294.      
  295.         
  296.     # full connect
  297.     with tf.variable_scope('softmax_linear') as scope:
  298.         weights = tf.get_variable('softmax_linear',
  299.                                   shape=[128, n_classes],
  300.                                   dtype=tf.float32,
  301.                                   initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
  302.         biases = tf.get_variable('biases', 
  303.                                  shape=[n_classes],
  304.                                  dtype=tf.float32, 
  305.                                  initializer=tf.constant_initializer(0.1))
  306.         logits = tf.add(tf.matmul(local4, weights), biases, name='softmax_linear')
  307.     
  308.     return logits
  309.  
  310.  
  311. if __name__ == '__main__':
  312.     x = tf.placeholder(tf.float32, shape=[None, 224, 224, 3])
  313.     model = MobileNetV2(x, num_classes=5, is_training=True)
  314.     print "output size:"
  315.     print model.output.get_shape()
  316.     board_writer = tf.summary.FileWriter(logdir='./', graph=tf.get_default_graph())
  317.  
  318.     fake_data = np.ones(shape=(1, 224, 224, 3))
  319.  
  320.     sess_config = tf.ConfigProto(device_count={'GPU':0})
  321.     with tf.Session(config=sess_config) as sess:
  322.         sess.run(tf.global_variables_initializer())
  323.  
  324.         cnt = 0
  325.         for i in range(101):
  326.             t1 = time.time()
  327.             output = sess.run(model.output, feed_dict={x: fake_data})
  328.             if i != 0:
  329.                 cnt += time.time() - t1
  330.         print(cnt / 100)

3. 训练

    他的训练文件train.py如下。tf.summary.*相关的为保存各个变量值的变化情况，便于在tensorboard中查看。  lr = tf.train.exponential_decay(learning_rate=init_lr, global_step=global_step, decay_steps=decay_steps, decay_rate=0.1) 为学习率随着迭代此时指数下降。

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    以及后面的:

    var_list = tf.trainable_variables() 
    g_list = tf.global_variables()
    bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
    bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
    var_list += bn_moving_vars
    saver = tf.train.Saver(var_list=var_list, max_to_keep=10)

表示更新mobilenetv2中batchnormal的移动平均和标准差，如果没有则训练时很好而预测时完全错误！！！

saver.save(sess, checkpoint_path, global_step=step)表示保存模型

  1. #coding:utf-8
  2. import os
  3. import numpy as np
  4. import tensorflow as tf
  5. import glob
  6.  
  7. import model
  8.  
  9.  
  10. def get_files(file_dir):
  11.     image_list, label_list = [], []
  12.     for label in os.listdir(file_dir):
  13.         for img in glob.glob(os.path.join(file_dir, label, "*.jpg")):
  14.             image_list.append(img)
  15.             label_list.append(int(label_dict[label]))
  16.     print('There are %d data' %(len(image_list)))
  17.     temp = np.array([image_list, label_list])
  18.     temp = temp.transpose()
  19.     np.random.shuffle(temp)
  20.     image_list = list(temp[:, 0])
  21.     label_list = list(temp[:, 1])
  22.     label_list = [int(i) for i in label_list]
  23.     return image_list, label_list
  24.  
  25. label_dict, label_dict_res = {}, {}
  26. # 手动指定一个从类别到label的映射关系
  27. with open("label.txt", 'r') as f:
  28.     for line in f.readlines():
  29.         folder, label = line.strip().split(':')[0], line.strip().split(':')[1]
  30.         label_dict[folder] = label
  31.         label_dict_res[label] = folder
  32. print(label_dict)
  33.  
  34.  
  35. train_dir = "/media/DATA2/sku_train"
  36. logs_train_dir = './model_save'
  37. init_lr = 0.1
  38. BATCH_SIZE = 64
  39. train, train_label = get_files(train_dir)
  40. one_epoch_step = len(train) / BATCH_SIZE
  41. decay_steps = 20*one_epoch_step
  42. MAX_STEP = 100*one_epoch_step
  43. N_CLASSES = len(label_dict)
  44. IMG_W = 224
  45. IMG_H = 224
  46. CAPACITY = 1000
  47. os.environ["CUDA_VISIBLE_DEVICES"] = "0" # gpu编号
  48. config = tf.ConfigProto()
  49. config.gpu_options.allow_growth = True # 设置最小gpu使用量
  50.  
  51.  
  52. def get_batch(image, label, image_W, image_H, batch_size, capacity):
  53.     image = tf.cast(image, tf.string)
  54.     label = tf.cast(label, tf.int32)
  55.     # make an input queue
  56.     input_queue = tf.train.slice_input_producer([image, label], shuffle=False)
  57.     label = input_queue[1]
  58.     image_contents = tf.read_file(input_queue[0])
  59.     image = tf.image.decode_jpeg(image_contents, channels=3)
  60.     # 数据增强
  61.     #image = tf.image.resize_image_with_pad(image, target_height=image_W, target_width=image_H)
  62.     image = tf.image.resize_images(image, (image_W, image_H))
  63.     # 随机左右翻转
  64.     image = tf.image.random_flip_left_right(image)
  65.     # 随机上下翻转
  66.     image = tf.image.random_flip_up_down(image)
  67.     # 随机设置图片的亮度
  68.     image = tf.image.random_brightness(image, max_delta=32/255.0)
  69.     # 随机设置图片的对比度
  70.     #image = tf.image.random_contrast(image, lower=0.5, upper=1.5)
  71.     # 随机设置图片的色度
  72.     image = tf.image.random_hue(image, max_delta=0.05)
  73.     # 随机设置图片的饱和度
  74.     #image = tf.image.random_saturation(image, lower=0.5, upper=1.5)
  75.     # 标准化,使图片的均值为0，方差为1
  76.     image = tf.image.per_image_standardization(image)
  77.     image_batch, label_batch = tf.train.batch([image, label],
  78.                                                 batch_size= batch_size,
  79.                                                 num_threads= 64,
  80.                                                 capacity = capacity)
  81.     tf.summary.image("input_img", image_batch, max_outputs=5)
  82.     label_batch = tf.reshape(label_batch, [batch_size])
  83.     image_batch = tf.cast(image_batch, tf.float32)
  84.     return image_batch, label_batch
  85.  
  86. def main():    
  87.     global_step = tf.Variable(0, name='global_step', trainable=False)    
  88.     # label without one-hot
  89.     batch_train, batch_labels = get_batch(train,
  90.                                           train_label,
  91.                                           IMG_W,
  92.                                           IMG_H,
  93.                                           BATCH_SIZE, 
  94.                                           CAPACITY)
  95.     # network
  96.     logits = model.MobileNetV2(batch_train, num_classes=N_CLASSES, is_training=True).output
  97.     #logits = model.model2(batch_train, BATCH_SIZE, N_CLASSES)
  98.     #logits = model.model4(batch_train, N_CLASSES, is_trian=True)
  99.     print logits.get_shape()
  100.     # loss
  101.     cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=batch_labels)
  102.     loss = tf.reduce_mean(cross_entropy, name='loss')
  103.     tf.summary.scalar('train_loss', loss)
  104.     # optimizer
  105.     lr = tf.train.exponential_decay(learning_rate=init_lr, global_step=global_step, decay_steps=decay_steps, decay_rate=0.1)
  106.     tf.summary.scalar('learning_rate', lr)
  107.  
  108.     update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
  109.     with tf.control_dependencies(update_ops):
  110.         optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize(loss, global_step=global_step)
  111.     # accuracy
  112.     correct = tf.nn.in_top_k(logits, batch_labels, 1)
  113.     correct = tf.cast(correct, tf.float16)
  114.     accuracy = tf.reduce_mean(correct)
  115.     tf.summary.scalar('train_acc', accuracy)
  116.     
  117.     summary_op = tf.summary.merge_all()
  118.     sess = tf.Session(config=config)
  119.     train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
  120.     
  121.     #saver = tf.train.Saver()
  122.     var_list = tf.trainable_variables() 
  123.     g_list = tf.global_variables()
  124.     bn_moving_vars = [g for g in g_list if 'moving_mean' in g.name]
  125.     bn_moving_vars += [g for g in g_list if 'moving_variance' in g.name]
  126.     var_list += bn_moving_vars
  127.     saver = tf.train.Saver(var_list=var_list, max_to_keep=10)
  128.     
  129.     sess.run(tf.global_variables_initializer())
  130.     coord = tf.train.Coordinator()
  131.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)
  132.     #saver.restore(sess, logs_train_dir+'/model.ckpt-174000') 
  133.     try:
  134.         for step in range(MAX_STEP):
  135.             if coord.should_stop():
  136.                     break
  137.             _, learning_rate, tra_loss, tra_acc = sess.run([optimizer, lr, loss, accuracy])
  138.             if step % 100 == 0:
  139.                 print('Epoch %3d/%d, Step %6d/%d, lr %f, train loss = %.2f, train accuracy = %.2f%%' %(step/one_epoch_step, MAX_STEP/one_epoch_step, step, MAX_STEP, learning_rate, tra_loss, tra_acc*100.0))
  140.                 summary_str = sess.run(summary_op)
  141.                 train_writer.add_summary(summary_str, step)
  142.             if step % 2000 == 0 or (step + 1) == MAX_STEP:
  143.                 checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
  144.                 saver.save(sess, checkpoint_path, global_step=step)
  145.     except tf.errors.OutOfRangeError:
  146.         print('Done training -- epoch limit reached')
  147.     finally:
  148.         coord.request_stop()
  149.         
  150.     coord.join(threads)
  151.     sess.close()
  152.     
  153.  
  154. if __name__ == '__main__':
  155.     main()

开始训练后，他在model_save文件夹下输入了：tensorboard --logdir=model_save

然后打开：http://localhost:6006/

他发现能看到，learning rate, accuracy, loss的变化情况了,也能看到训练过程中的图像及网络结构了。

 

下一篇：用训练的模型预测图像https://blog.csdn.net/u010397980/article/details/84932383

或者：用官方的slim定义网络结构进行训练https://blog.csdn.net/u010397980/article/details/89439714

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/672840
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号