物体检测项目
1、项目介绍
1.1 项目架构设计
实现基于tensorflow的物体检测。项目框架主要分为三部分：数据采集层、深度模型层、用户层。其中，数据采集层用于对数据进行标记以及转换成TFRecords格式数据文件。深度模型层的功能是读取数据采集层输出的TFRecords数据进行数据的预处理以及对深度模型的训练，其中深度模型可以使用不同的框架（例如SSD、YOLO等），通过模型工厂进行选择，本项目中使用SSD物体检测框架。训练得到的模型通过tensorflow serving进行部署，提供给后台。用户层通过前端和后台业务交互得到想要的结果。项目结构如下：
图1 物体检测项目框架
使用TensorflowServing进行模型部署有以下几个好处：
1、可以进行模型的热更新：只要上传模型文件到服务器上即可，TensorFlow会自动识别模型并使用，不需要重启serving 服务。
2、导出模型和使用模型进行解耦合
图2 TensorflowServing模型部署逻辑
整个项目开发流程主要分为两大部分：
1.模型的训练与测试
训练
数据集处理（将数据转换成TFRecords格式文件）
数据读取
preprocess（数据预处理）
网络构建预测结果
损失计算并训练
模型保存
测试
测试数据
preprocess（数据预处理）
模型加载
postprocess（预测结果后期处理）
预测结果显示（matplotlib）
2、模型部署与小程序
模型导出
TensorFlow Serving部署模型
Serving客户端+Flask Web
小程序前端
1.2 项目代码训练架构设计
图2 项目代码训练架构设计
其中：
1.数据集工厂（data factory）
为了使项目能够读取不同的数据集
2.预处理工厂（preprocess factory）
为了处理不同模型要求的处理需求
3.模型工厂（model factory）
为了项目训练数据能够使用不同的模型
1.3 训练代码架构设计意义
1.网络模型和网络模型之间不交叉，模型和数据之间解耦合，数据集与预处理逻辑之间解耦合；
2.训练代码可以调用不同的模型与不同的数据集训练不同的模型结果。
2. 数据模块接口
获取到的图片数据集，保存在IMAGE/commodity/JPEGImages文件下。使用图片标记工具（本项目使用labelimg）将图片进行标记，输出XML格式文件，保存在 IMAGE/commodity/Annotatons文件下。这样的数据集类似PASCAL VOC数据集，数据集的图片和标记文件分布在不同的文件中，并且图片和标签没有一一对应，后续项目中不方便处理，也不方便项目的解耦合。tensorflow提供了TFRecord个数来统一存储数据，TFRecord格式是一种将图像数据和标签数据存放在一起的二进制文件，在tensorflow中能够快速处理。因此项目中需要将数据集转换成TFRecords文件。TFRecord文件中的数据是通过tf.train.Example Protocol Buffer格式存储的。每个我想ample对应一张图片，其中包括图片的各种信息。特点是：
1）体积小，消息大小只需要xml文件的1/10~1/3；
2）解析速度快：解析速度比xml块20~100倍。
其中，tf.train.Example的定义见本博客的《TFRecord数据处理》一节。
2.1 数据转换成TFRecord格式文件
2.1.1 转换步骤：
1）设定每个tfrecord文件中保存多的样本个数
2）读取每张图片内容以及xml文件
3）将每次去读内容写入tfrecord文件
2.1.2 数据转换成TFRecord文件
代码结构如图所示：
图3 图片转换成tfrecord文件
其中，datasets文件夹下的utils存放读取数据的公用组件；dataset_config.py存放数据读取的配置；dataset_to_tfrecords.py为主要的数据转换逻辑。dataset_to_tfrecord.py文件执行dataset_to_tfrecords.py中的run()函数完成数据转换。具体代码如下：
2.1.2.1 配置文件dataset_config.py如下：
""" 数据集转换配置文件 """ # 指定原始图片的XML和图片的文件夹名字 DIRECTORY_ANNOTATIONS = "Annotations/" DIRECTORY_IMAGES = "JPEGImages/" # 指定每个TFRecord文件存储example的数量 SAMPLER_PER_FILES = 200 # 定义字典，保存数据集的类别 # 字典的key是类别，字典的value是一个元组 # 元组的元素不能修改，元组中是类别代表的数字和类别 VOC_LABELS = { 'none': (0, 'Background'), 'clothes': (1, 'clothes'), 'pants': (2, 'pants'), 'shoes': (3, 'shoes'), 'watch': (4, 'watch'), 'phone': (5, 'phone'), 'audio': (6, 'audio'), 'computer': (7, 'computer'), 'books': (8, 'books') }
2.1.2.2 utils文件下的dataset_utils.py文件中，编写定义tf Example需要的feature转换公式，代码如下：
import tensorflow as tf # 生成整数型的属性 def int64_feature(value): if not isinstance(value, list): value = [value] return tf.train.Feature(int64_list=tf.train.Int64List(value=value)) # 生成浮点型的属性 def float_feature(value): if not isinstance(value, list): value = [value] return tf.train.Feature(float_list=tf.train.FloatList(value=value)) # 生成字符串类型的属性 def bytes_feature(value): if not isinstance(value, list): value = [value] return tf.train.Feature(bytes_list=tf.train.BytesList(value=value))
2.1.2.3 dataset_to_tfrecords.py文件下主要编写编写转换逻辑，代码如下：
import tensorflow as tf import os import xml.etree.ElementTree as ET from datasets.dataset_config import DIRECTORY_ANNOTATIONS, DIRECTORY_IMAGES, SAMPLER_PER_FILES, VOC_LABELS from datasets.utils.dataset_utils import int64_feature, float_feature, bytes_feature # 获取输出的TFRecord文件名字，格式如下：commodity_2018_train_xxx.tfrecord # xxx代表序号，从000开始 def _get_output_filename(outputdir, dataset_name, fdx): """ 获取输出的TFRecord文件的名字 :param outputdir: 输出路径 :param dataset_name: 数据集名字 :param fdx: 文件id :return: """ return "%s/%s_%03d.tfrecord" % (outputdir, dataset_name, fdx) def _process_image(dataset_dir, image_name): """ 处理一张图片的数据：获取图片数据以及xml文件中的内容。根据需要获取 :param dataset_dir: 数据集路径 :param img_name: 图片名字 :return: """ # 图片路径 + 图片名字 filename = dataset_dir + DIRECTORY_IMAGES + image_name + '.jpg' # 读取图片数据 image_data = tf.gfile.FastGFile(filename, 'rb').read() # 读取xml数据，使用ET工具 # 构造xml文件名字 filename_xml = dataset_dir + DIRECTORY_ANNOTATIONS + image_name + '.xml' # 将文件内容转换成树状结构tree tree = ET.parse(filename_xml) # 获取root节点 root = tree.getroot() # 获取root节点下面的子节点 # 1、获取size信息 size = root.find('size') # 把height、width、depth存放在一个shape里面 shape = [int(size.find('height').text), int(size.find('width').text), int(size.find('depth').text)] # 用于存储object对应的label的编号 labels = [] labels_text = [] difficults = [] truncated = [] bboxes = [] # 2、获取 object信息 for obj in root.findall('object'): # 解析每一个object，包含name、difficult、truncated、bndbox[xmin, ymin, xmax, ymax] # 取出label和与之对应的数字 label = obj.find('name').text labels.append(int(VOC_LABELS[label][0])) labels_text.append(label.encode('ascii')) # 取出difficult if obj.find('difficult'): difficults.append(int(obj.find('difficult').text)) else: # 不存在，默认difficult为0 difficults.append(0) # 取出truncated if obj.find('truncated'): truncated.append(int(obj.find('truncated').text)) else: # 不存在，默认truncated为0 truncated.append(0) # 取出bndbox bbox = obj.find('bndbox') bboxes.append([float(bbox.find('ymin').text)/shape[0], float(bbox.find('xmin').text) / shape[1], float(bbox.find('ymax').text) / shape[0], float(bbox.find('xmax').text) / shape[1]]) return image_data, shape, labels, labels_text, difficults, truncated, bboxes def _convert_to_example(image_data, shape, labels, labels_text, difficults, truncated, bboxes): """ 将图片数据转换成example protocol buffer格式 :param image_data: :param shape: :param labels: :param difficults: :param truncated: :param bboxes: :return: """ # bboxes存储格式如下：[[a0, b0, c0, d0], [a1, b1, c1, d1]]转换成 # ymin[a0, a1], xmin[b0, b1], ymax[c0, c1], xmax[d0, d1] ymin = [] xmin = [] ymax = [] xmax = [] for b in bboxes: ymin.append(b[0]) xmin.append(b[1]) ymax.append(b[2]) xmax.append(b[3]) # 将所有信息封装成example image_format = b'JPEG' example = tf.train.Example(features=tf.train.Features(feature={ 'image/height': int64_feature(shape[0]), 'image/width': int64_feature(shape[1]), 'image/channels': int64_feature(shape[2]), 'image/shape': int64_feature(shape), 'image/object/bbox/ymin': float_feature(ymin), 'image/object/bbox/xmin': float_feature(xmin), 'image/object/bbox/ymax': float_feature(ymax), 'image/object/bbox/xmax': float_feature(xmax), 'image/object/bbox/label': int64_feature(labels), 'image/object/bbox/difficult': int64_feature(difficults), 'image/object/bbox/truncated': int64_feature(truncated), 'image/object/bbox/label_text': bytes_feature(labels_text), 'image/format': bytes_feature(image_format), 'image/encoded': bytes_feature(image_data)})) return example def _add_to_tfrecord(dataset_dir, image_name, tfrecord_writer): """ 添加一个图片文件和xml内容写入文件中 :param dataset_dir: 数据集目录 :param img_name: 图片名 :param tfrecord_writer: 文件写入实例 :return: """ # 1、读取每张图片内容及其对应的xml文件的内容 image_data, shape, labels, labels_text, difficults, truncated, bboxes = _process_image(dataset_dir, image_name) # 2、将每张图片的数据封装成一个example example = _convert_to_example(image_data, shape, labels, labels_text, difficults, truncated, bboxes) # 3、使用tfrecord_writer将example序列化结果写入TFRecord文件 tfrecord_writer.write(example.SerializeToString()) return None def run(dataset_dir, output_dir, dataset_name="data"): """ 运行转换代码逻辑：存入tfrecord文件，每个文件固定N个样本 :param dataset_dir: 数据集目录 :param output_dir: TFRecord存储目录 :param dataset_name: 数据集名字，指定名字以及train_or_test :return: """ # 1、判断数据集目录是否存在，不存在则创建一个目录 if not tf.gfile.Exists(dataset_dir): tf.gfile.MakeDirs(dataset_dir) # 2、读取某个文件夹下的所有文件名字列表 path = os.path.join(dataset_dir, DIRECTORY_ANNOTATIONS) # 读取所有文件，返回所有文件名字列表。但是会打乱顺序,需要使用sorted函数进行排序 filenames = sorted(os.listdir(path)) # 3、循环遍历列表，每N张图片和XML信息存储到一个tfrecord文件中 i = 0 fdx = 0 while i < len(filenames): # 1、创建TFRecord文件 tf_filename = _get_output_filename(output_dir, dataset_name, fdx) # 每N个文件存储一次 # 新建tfrecord的存储器 with tf.python_io.TFRecordWriter(tf_filename) as tfrecord_writer: j = 0 while i < len(filenames) and j < SAMPLER_PER_FILES: print("转换图片进度%d/%d" % (i+1, len(filenames))) # 取出图片以及xml的名字 single_filename = filenames[i] image_name = single_filename[:-4] # 读取图片和xml内容，存入图片，每次构造一个图片文件存储指定文件 _add_to_tfrecord(dataset_dir, image_name, tfrecord_writer) i += 1 j += 1 # 每N个数据，文件id增加计数 fdx += 1 print("数据集 %s 转换成功" % dataset_name)
2.1.2.4 dataset_to_tfrecords.py文件代码
from datasets import dataset_to_tfrecords if __name__ == '__main__': dataset_to_tfrecords.run('./IMAGE/commodity/', './IMAGE/tfrecords/commodity_tfrecords/', 'commodity_2018_train')
为了实现数据格式的转换，需要在图3的IMAGE文件夹下分别放置如下目录：
commodity/Annotations/
commodity/JPEGImages/
tfrecords/commodity_tfrecords/
其中，commodity/Annotations/路径下存放标记过的xml格式文件；commodity/JPEGImages/路径下存放于xml格式对应的图片数据；tfrecords/commodity_tfrecords/路径用于存放转换好的tfrecord格式数据。
2.2 TFRecord格式文件读取
TFRecord文件读取有两种方法：
1）使用tensorflow进行实现
2）使用tensorflow.slim库进行实现
本项目使用tensorflow.slim进行实现，具体步骤如下：
1、定义解码器decoder
decoder = tf.slim.tfexample_decoder.TFExampleDecoder()
其中，定义解码器时，需要制定两个参数：keys_to_features,和items_to_handlers两个字典参数。key_to_features这个字典需要和TFrecord文件中定义的字典项匹配。items_to_handlers中的关键字可以是任意值，但是它的handler的初始化参数必须要来自于keys_to_features中的关键字。
2、定义dataset
dataset= tf.slim.dataset.Dataset()
其中，定义dataset时需要将datasetsource、reader、decoder、num_samples等参数
3、定义provider
provider = slim.dataset_data_provider.DatasetDataProvider
其中，需要的参数为：dataset, num_readers, reader_kwargs, shuffle, num_epochs,common_queue_capacity,common_queue_min, record_key=',seed, scope等。
4、调用provider的get方法
获取items_to_handlers中定义的关键字
5、利用分好的batch建立一个prefetch_queue
6、prefetch_queue中有一个dequeue的op，每执行一次dequeue则返回一个batch的数据。
具体代码如下（这里先只介绍到通过provider的get函数获取数据，后面步骤5和步骤6的队列处理先不介绍，在实际项目代码中会使用到）：
import os import tensorflow as tf slim = tf.contrib.slim def get_dataset(dataset_dir): """ 获取commodity2018数据集 :param dataset_dir: 数据集目录 :return: Dataset """ # 1.准备 tf.slim.dataset.Dataset()的参数 # 1.1第一个参数：dataset file_pattern = os.path.join(dataset_dir, "commodity_2018_train_*.tfrecord") # 1.2第二个参数：reader reader = tf.TFRecordReader # 1.3第三个参数：decoder # 创建decoder需要两个参数：keys_to_features和items_to_handlers # 1.3.1 定义keys_to_features，反序列化的格式 keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/height': tf.FixedLenFeature([1], tf.int64), 'image/width': tf.FixedLenFeature([1], tf.int64), 'image/channels': tf.FixedLenFeature([1], tf.int64), 'image/shape': tf.FixedLenFeature([3], tf.int64), 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64), } # 1.3.2 items_to_handlers，反序列化成高级的格式 items_to_handlers = { 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'), 'shape': slim.tfexample_decoder.Tensor('image/shape'), 'object/bbox': slim.tfexample_decoder.BoundingBox( ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/'), 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'), 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'), 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'), } # 1.3.3构造decoder decoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) # 2.tf.slim.dataset.Dataset()并返回 return slim.dataset.Dataset(data_sources=file_pattern, reader=reader, decoder=decoder, num_samples=88, items_to_descriptions={ 'image': 'A color image of varying height and width.', 'shape': 'Shape of the image', 'object/bbox': 'A list of bounding boxes, one per each object.', 'object/label': 'A list of labels, one per each object.' }, # 数据集返回的格式描述字典 num_classes=8)
from datasets.dataset_init import commodity_2018 import tensorflow as tf slim = tf.contrib.slim if __name__ == '__main__': # 获取dataset dataset = commodity_2018.get_dataset("./IMAGE/tfrecords/commodity_tfrecords/") # 通过provider取出数据 provider = slim.dataset_data_provider.DatasetDataProvider(dataset=dataset, num_readers=3) # 通过get方法获取指定名称的数据（名称在准备规范数据dataset时高级格式的名称，即items_to_handlers中定义的名称） [image, shape, bbox, label, difficult, truncated] = provider.get( ['image', 'shape', 'object/bbox', 'object/label', 'object/difficult', 'object/truncated']) print(image, shape, bbox, label, difficult, truncated)
最后得到如下输出结果：
图4 输出tfrecord文件
2.3 数据模块接口——数据工厂的实现
功能需求：
1）原始数据集（图片+XML）转换成TFRecords文件格式
2）读取TFRecords数据
数据模块设计的目录如下：
图5 数据模块接口
其中：
dataset_factory：数据模块工厂，找到不同的数据集读取逻辑；
dataset_init：保存不同数据集的TFRecords格式读取功能；
utils：数据模块的共用组件
dataset_config‘：数据模块的一些数据集配置文件
dataset_to_tfrecords：原始数据集格式转换逻辑
2.3.1 格式转换
上一节以及介绍了将数据集转换成TFRecord格式文件，这里就不再赘述。
2.3.2 读取TFRecord文件数据
2.3.2.1 读取代码框架设计
数据模块需要实现对不同数据集类型进行读取操作，因此可以定义一个基类，同时不同数据集继承这个基类。类的设计如下：
图6 数据读取基类设计
2.3.2.2 数据读取代码
1.在dataset_utils.py中新建一个基类，该文件下的代码如下：
import tensorflow as tf # 定义数据集TFRecord文件读取基类 class TFRecordsReaderBase(object): """ 数据集读取基类 """ def __init__(self, param): # param是给不同数据集使用的属性配置 self.param = param def get_dataset(self, train_or_test, dataset_dir): """ 获取数据 :param train_or_test: 训练还是测试 :param dataset_dir: 数据集目录 :return: """ return None
2. 因为在读取TFRecord数据时，不同的数据集，都会有自己特有的参数（比如：文件名、样本数、类别数等）。因此在dataset_config.py文件中定义不同数据集的参数，作为继承类的参数。这里使用命名字典：
""" 数据集读取 """ from collections import namedtuple # 创建命名字典，用于存放读取数据类中的param参数 DataSetParams = namedtuple("DataSetParamters", ['FILE_PATTERN', 'NUM_CLASSES', 'SPLITS_TO_SIZES', 'ITEMS_TO_DESCRIPTIONS' ]) # 定义commodity_2018属性配置 Cmd2018 = DataSetParams( FILE_PATTERN='commodity_2018_%s_*.tfrecord', NUM_CLASSES=8, SPLITS_TO_SIZES={ 'train': 88, 'test': 0 }, ITEMS_TO_DESCRIPTIONS={ 'image': '图片数据', 'shape': '图片形状', 'object/bbox': '若干物体对象的bbox框组成的列表', 'object/label': '若干物体对应的label编号' } )
3. 继承基类来定义派生类用于处理不同数据集
继承的基类存放在dataset/dataset_init/目录下。对于不同数据集，定义不同的文件继承基类，本项目值处理commodity数据集，因此仅创建commodity_2018.py继承基类，代码如下：
import os import tensorflow as tf from datasets.utils import dataset_utils slim = tf.contrib.slim class CommodityTFRecords(dataset_utils.TFRecordsReaderBase): """ 商品数据集读取类 """ def __init__(self, param): self.param = param def get_dataset(self, train_or_test, dataset_dir): """ 获取commodity2018数据集 :param train_or_test: train or test :param dataset_dir: 数据集目录 :return: """ # 参数检查，异常抛出 if train_or_test not in ['train', 'test']: raise ValueError("训练/测试的名字 %s 错误" % train_or_test) if not tf.gfile.Exists(dataset_dir): raise ValueError("数据集目录 %s 不存在" % dataset_dir) # 1.准备 tf.slim.dataset.Dataset()的参数 # 1.1第一个参数：dataset file_pattern = os.path.join(dataset_dir, self.param.FILE_PATTERN % train_or_test) # 1.2第二个参数：reader reader = tf.TFRecordReader # 1.3第三个参数：decoder # 创建decoder需要两个参数：keys_to_features和items_to_handlers # 1.3.1 定义keys_to_features，反序列化的格式 keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/height': tf.FixedLenFeature([1], tf.int64), 'image/width': tf.FixedLenFeature([1], tf.int64), 'image/channels': tf.FixedLenFeature([1], tf.int64), 'image/shape': tf.FixedLenFeature([3], tf.int64), 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64), } # 1.3.2 items_to_handlers，反序列化成高级的格式 items_to_handlers = { 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'), 'shape': slim.tfexample_decoder.Tensor('image/shape'), 'object/bbox': slim.tfexample_decoder.BoundingBox( ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/'), 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'), 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'), 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'), } # 1.3.3构造decoder decoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers) # 2.tf.slim.dataset.Dataset()并返回 return slim.dataset.Dataset(data_sources=file_pattern, reader=reader, decoder=decoder, num_samples=self.param.SPLITS_TO_SIZES[train_or_test], items_to_descriptions=self.param.ITEMS_TO_DESCRIPTIONS, # 数据集返回的格式描述字典 num_classes=self.param.NUM_CLASSES)
2.3.3 定义数据工厂
在datasets根目录下创建dataset_factory.py文件，定义数据工厂获取数据，代码如下：
from datasets.dataset_init import commodity_2018 from datasets.dataset_config import Cmd2018 # 定义dataset种类的字典，目前只是有commodity数据集，后续可以添加 datasets_maps = { 'commodity_2018': commodity_2018.CommodityTFRecords } # 定义参数种类的字典，不同数据集，param参数不一样，目前只是有commodity的参数，后续可以添加 param_map = { 'commodity_2018': Cmd2018 } def get_dataset(dataset_name, train_or_test, dataset_dir): """ 获取指定数据名称的数据文件 :param dataset_name: 数据集名称（数据当中要存在 :param train_or_test: train or test数据集 :param dataset_dir: 数据集目录 :return: Dataset 数据规范 """ if dataset_name not in datasets_maps: raise ValueError("数据集名称 %s 不存在" % dataset_name) param = param_map[dataset_name] return datasets_maps[dataset_name](param).get_dataset(train_or_test, dataset_dir)
最终对外只提供dataset_factory.py文件用于读取TFRecord文件。
3. 模型接口
本项目使用SSD模型。
项目文件结构如下：
图7 网络模型接口文件格式
其中的公共组件的源码都是已知的，本项目使用的ssd网络模型实现文件ssd_vgg_300.py相关代码都是现有代码。对于SSD模型以及其代码实现，将在另外章节介绍。
3.1 网络工厂nets_factory实现
类似数据工厂，我们定义模型工厂nets_factory.py文件，代码如下：
from nets.nets_model import ssd_vgg_300 nets_maps = { 'ssd_vgg_300': ssd_vgg_300.SSDNet } def get_network(network_name): """ 获取不同网络模型 :param network_name: 网络模型名称 :return: 网络 """ if network_name not in nets_maps: raise ValueError("网络名称 %s 不存在" % network_name) return nets_maps[network_name]
4.预处理模块
目的：
1）在图像的深度学习中，对输入数据进行数据增强（Data Augmentation），为了丰富图像的训练集，更好地提取图像特征，泛化模型（防止过拟合）。
通过一系列图像的操作（比如：剪切、翻转、偏移、缩放等图像变换），增加数据集的大小，防止过拟合。
2）还有一个根本目的就是把图片变成符合大小要求的格式：
RCNN网络对于输入图片没有要求，但是网络当中卷积之前需要的大小为227×227；
YOLO算法：输入图片大小为448×448；
SSD算法：输入图片大小为300×300；
4.1 预处理模块代码实现
首先，预处理模块的结构如图所示：
图8 预处理模块结构
其中，需要创建一个preprocessing目录，该目录下的文件用于数据预处理。该目录下的processing目录中的ssd_vgg_preprocessing.py是对于SSD模型的预处理的。如果后续需要增加网络模型，需要在这个文件夹下增加预处理的文件。utils中是预处理需要用到的公共组件。这些相关代码都是公开的代码，这里不做介绍。有了上面的基础文件，下面就来完成数据预处理工厂代码的编写，在preprocessing_factory.py文件中实现：
from preprocessing.processing import ssd_vgg_preprocessing # 目前只有sdd_vgg_300，后续可以增加 preprocessing_maps = { 'ssd_vgg_300': ssd_vgg_preprocessing } def get_preprocessing(name, is_trainning=True): """ 预处理工厂获取不同的数据增强方法 :param name: 预处理名称 :param is_trainning: 是否是训练 :return: 返回预处理的函数，后续再调用函数 """ if name not in preprocessing_maps: raise ValueError("数据预处理名称 %s 不存在" % name) # 定义一个预处理函数，用于函数返回，后续再调用该预处理函数 def preprocessing_fn(image, labels, bboxes, out_shape, data_format, **kwargs): return preprocessing_maps[name].preprocess_image(image, labels, bboxes, out_shape, data_format=data_format, is_training=is_trainning, **kwargs) return preprocessing_fn
5.训练不同模块接口参数
对于2、3、4章节，只是分别单独介绍了数据模块接口、模型接口以及数据预处理接口。现在需要统一每一个模块接口提供给训练的参数，整理成文档。这样以后就直接查看文档即可调用相关模块。总结如图9所示：
图9 训练不同模型参数
6. 多GPU训练
终于到了模型训练这一步了。这里介绍多GPU训练。
对于深度学习来说，大量的计算量导致CPU会显得十分乏力耗时。所以需要GPU来进行提供帮助计算，那么他们的主要任务就是计算得出结果，与CPU之间会进行分工，CPU会做一些基本工作，变量存储，更新参数，输入数据变量等等。如图10所示。在TensorFlow当中会通过标号来区别不同的GPU和CPU，如 ，''/device:CPU:0", "/device:CPU:1","/device:GPU:0","/device:GPU:1","/device:GPU:2"，那么这些标号都是程序自动给的编号，指的具体哪块计算设备。
图10 CPU与GPU之间的分工合作
6.1 训练步骤
- 步骤
- 数据读取
- preprocess(数据预处理)
- 网络构建预测结果
- 损失计算
- 添加变量到TensorBoard
- 模型训练、保存
- 部署需求：训练整个模型需要在多GPU、多计算机的环境下进行
那么接下来首先我们要讲模型训练的设备逻辑原理弄清楚，如图11所示：
图11 模型训练的设备逻辑原理
训练主要是在设备（GPU/CPU）上训练，但是如果我们利用目前简单的TensorFlow提供的API去进行指定设备训练会比较繁琐。所以在这里需要介绍一个TensorFlow提供的最新的专门用于多GPU，多计算机的设备部署模块——model_deploy。
6.2 model_deploy介绍
model_deploy位于TensorFlow slim模块的deployment目录下，可以使得用多个 GPU / CPU在同一台机器或多台机器上执行同步或异步训练变得更简单。可以从如下官方地址下载：
https://github.com/tensorflow/models/blob/master/research/slim/deployment/model_deploy.py
首先我们要介绍：
replica：使用多机训练时，一台机器对应一个replica（复本）；
clone：由于tensorflow里多GPU训练一般都是每个GPU上都有完整的模型，各自进行前向传播计算，得到的梯度交给CPU平均后统一反向计算，每个GPU上的模型叫做一个clone；
parameter server：多机训练时，计算梯度平均值并执行反向传播操作的参数，功能类似于单机多GPU的CPU；
worker server：一般指单机多卡中的GPU，用于训练。
6.2.1 DeploymentConfig
1. DeploymentConfig为文件中的一个类，主要用于给变量配置选择的设备。
- class DeploymentConfig(object):
- 配置参数
- num_clones=1:每一个计算设备上的模型克隆数（每台计算机的GPU/CPU总数）
- clone_on_cpu=False:如果为True，将只在CPU上训练
- replica_id=0:指定某个计算机去部署，默认第0台计算机（TensorFlow会给个默认编号）
- num_replicas=1:多少台可用计算机
- num_ps_tasks=0:用于参数服务器的计算机数量，0为不适用计算机作为参数服务器
- worker_job_name='worker':工作服务器名称
- ps_job_name='ps':参数服务器名称
- config.variables_device()
- 作为tf.device(func)的参数，返回默认创建变量的设备
- 一般用于指定全局步数变量的设备，默认运行计算机的"/device:CPU:0"
- config.inputs_device()
- 作为tf.device(func)的参数，返回用于构建数据输入变量所在的设备。
- 默认运行计算机的"/device:CPU:0"
- config.optimizer_device()
- 作为tf.device(func)的参数，返回学习率、优化器所在的设备。
- 默认运行计算机的"/device:CPU:0"
- config.clone_scope(self, clone_index):
- 返回指定编号的设备命名空间
- 按照这样编号，clone_0,clone_1...
6.2.2 model_deploy定义的相关函数，主要用于为每一个clone创建一个复制的模型（在GPU）
- model_deploy.create_clones(config, model_fn, args=None, kwargs=None):
- 作用：每个clone创建一个复制的模型，给GPU进行clone模型
- config:一个DeploymentConfig的配置对象
- model_fn：用于回调的函数model_fn，
- args=None, kwargs=None：回调函数model_fn的参数
- 返回元组组成的列表，列表个数大小为指定的num_clones数量
- Clone(outputs, scope, device)
- outputs：网络模型的每一层节点
- scope: 第i个GPU设备的命名空间，config.clone_scope(i)
- clone_device:第i个GPU设备
- Clone(outputs, scope, device)
- model_deploy.optimize_clones(clones, optimizer,regularization_losses=None, **kwargs)
- 作用：计算所有给定的clones的总损失以及每个需要优化的变量的总梯度
- clones: 元组列表，每个元素Clone(outputs, scope, device)
- optimizer：选择的优化器
- **kwargs：可选参数，优化器优化的变量
- 返回：
- total_loss：总损失
- grads_and_vars：每个需要优化变量的总梯度组成的列表
源码介绍使用：
# Set up DeploymentConfig config = model_deploy.DeploymentConfig(num_clones=2, clone_on_cpu=True) # Create the global step on the device storing the variables. with tf.device(config.variables_device()): global_step = slim.create_global_step() # Define the inputs with tf.device(config.inputs_device()): images, labels = LoadData(...) inputs_queue = slim.data.prefetch_queue((images, labels)) # Define the optimizer. with tf.device(config.optimizer_device()): optimizer = tf.train.MomentumOptimizer(FLAGS.learning_rate, FLAGS.momentum) # Define the model including the loss. def model_fn(inputs_queue): images, labels = inputs_queue.dequeue() predictions = CreateNetwork(images) slim.losses.log_loss(predictions, labels) model_dp = model_deploy.deploy(config, model_fn, [inputs_queue], optimizer=optimizer) # Run training. slim.learning.train(model_dp.train_op, my_log_dir, summary_op=model_dp.summary_op)
6.3 训练逻辑
1）DeploymentConfig
需要在训练之前配置所有的设备信息
定义全局步数
2）获取图片队列
在config.inputs_device()指定
3）数据输入、网络计算结果、定义损失并复制模型到clones，添加变量到tensorboard
model_deploy.create_clones
4）定义学习率、优化器
config.optimizer_device()指定
5）计算所有GPU/CPU设备的平均损失和每个变量的梯度总和、定义训练OP、summaries OP
model_deploy.optimize_clones
6）配置训练的config，进行训练
slim.learning.train
代码框架如下：
图中，pre_trained文件下存放的是预训练好的ssd_vgg_300网络的预训练模型，fine_tuning是训练存放模型的路径。
根目录下的utils是公共组件，最后训练的文件是train_ssd_network.py。
训练代码如下：
""" 训练初始化参数 PRE_TRAINED_PATH=./ckpt/pre_trained/ssd_vgg_300.ckpt TRAIN_MODEL_PDIR=./ckpt/fine_tuning/ DATASET_DIR=./IMAGE/tfrecords/commodity_tfrecords/ 每批次训练样本数：32或者更小 惩罚项：0.005 学习率：0.001 优化器选择：adam 模型名称：ssd_vgg_300 """ import tensorflow as tf from datasets import dataset_factory from preprocessing import preprocessing_factory from nets import nets_factory from utils import train_tools from deployment import model_deploy slim = tf.contrib.slim DATA_FORMAT = 'NHWC' # 命令行参数 # 设备相关的命令行参数 tf.app.flags.DEFINE_integer('num_clones', 1, "可用GPU数量") tf.app.flags.DEFINE_boolean('clone_on_cpu', False, "是否只在CPU上运行") tf.app.flags.DEFINE_integer('replica_id', 0, "复本id") # 数据集相关命令行参数 tf.app.flags.DEFINE_string('dataset_dir', ' ', "训练数据集目录") tf.app.flags.DEFINE_string('dataset_name', 'commodity_2018', "数据集名称") tf.app.flags.DEFINE_string('train_or_test', 'train', "训练还是测试") # 网络相关命令行参数 tf.app.flags.DEFINE_string('network_name', 'ssd_vgg_300', "网络名称") tf.app.flags.DEFINE_integer('batch_size', 32, "每批次获取样本换数量") tf.app.flags.DEFINE_float('weight_decay', 0.0001, "网络误差惩罚项") # 训练相关参数 tf.app.flags.DEFINE_string( 'optimizer', 'rmsprop', '优化器种类 可选"adadelta", "adagrad", "adam","ftrl", "momentum", "sgd" or "rmsprop".') tf.app.flags.DEFINE_string( 'learning_rate_decay_type', 'exponential', '学习率种类 "fixed", "exponential", "polynomial".') tf.app.flags.DEFINE_float('learning_rate', 0.01, '模型初始学习率') tf.app.flags.DEFINE_float('end_learning_rate', 0.0001, '模型终止学习率') tf.app.flags.DEFINE_integer('max_number_of_steps', None, '训练的最大步数') tf.app.flags.DEFINE_string('train_model_dir', ' ', '训练输出的模型目录') tf.app.flags.DEFINE_string('pre_trained_model', None, '预训练模型目录') FLAGS = tf.app.flags.FLAGS def main(_): if not FLAGS.dataset_dir: raise ValueError("必须指定一个TFRecord的数据集目录") # 设置打印级别 tf.logging.set_verbosity(tf.logging.DEBUG) # 在默认图中进行训练 with tf.Graph().as_default(): # 1.DeploymentConfig配置 deploy_config = model_deploy.DeploymentConfig(num_clones=FLAGS.num_clones, clone_on_cpu=FLAGS.clone_on_cpu, replica_id=0, num_replicas=1, num_ps_tasks=0) # 在variables_device定义全局步长（网络训练一般都这么配置） with tf.device(deploy_config.variables_device()): global_step = tf.train.create_global_step() # 2.获取图片数据，做一些预处理 # image, shape, bbox, label # 不是直接进行训练，而是需要进行正负样本标记（输出的anchor和GT进行IOU计算选择） # 2.1步骤如下： # (1)通过数据工厂获取DataSet规范，不是真正的数据，需要通过后续操作去获取数 dataset = dataset_factory.get_dataset(dataset_name=FLAGS.dataset_name, train_or_test=FLAGS.train_or_test, dataset_dir=FLAGS.dataset_dir) # (2)通过网络计算获取的anchors结果 # 通过网络工厂获取网络 ssd_class = nets_factory.get_network(FLAGS.network_name) # 获取默认网络参数 ssd_params = ssd_class.default_params._replace(num_classes=9) # 初始化网络init函数 ssd_net = ssd_class(ssd_params) # 获取shape ssd_shape = ssd_net.params.img_shape # 获取anchors, SSD网络中6层的所有计算出来的默认候选框default boxes ssd_anchors = ssd_net.anchors(ssd_shape) # (3)获取预处理函数 image_preprocessing_fn = preprocessing_factory.get_preprocessing(name=FLAGS.network_name, is_training=True) # 打印网络相关参数 train_tools.print_configuration(ssd_params, dataset.data_sources) # 2.2 # （1）通过slim.dataset_data_provider.DatasetDataProvider获取图像数据 # （2）进行数据预处理 # （3）对获取出来的GT标签和bbox进行编码 # （4）获取的单个样本数据，要进行批处理以及返回队列 with tf.device(deploy_config.inputs_device()): with tf.name_scope(FLAGS.network_name + "_data_provider"): provider = slim.dataset_data_provider.DatasetDataProvider( dataset, num_readers=4, common_queue_capacity=20 * FLAGS.batch_size, common_queue_min=10 * FLAGS.batch_size, shuffle=True) # get获取数据（真正获取参数） [image, shape, glabels, gbboxes] = provider.get(['image', 'shape', 'object/label', 'object/bbox']) # 数据预处理 [?, ?, 3]-->[300, 300, 3] image, glabels, gbboxes = image_preprocessing_fn(image, glabels, gbboxes, ssd_shape, DATA_FORMAT) # 原始anchor boxes进行正负样本标记 # gclasses: 目标类别 # glocalizations： 目标类别的真实位置 # gscores: 目标结果（概率值） gclasses, glocalizations, gscores = ssd_net.bboxes_encode(glabels, gbboxes, ssd_anchors) # 批处理、队列处理 # tensor_list:tensor组成的类别 [tensor, tensor, tensor, ...] # r是1个tensor组成的列表 r = tf.train.batch(tensors=train_tools.reshape_list([image, gclasses, glocalizations, gscores]), batch_size=FLAGS.batch_size, num_threads=4, capacity=5 * FLAGS.batch_size) batch_queue = slim.prefetch_queue.prefetch_queue(r, capacity=deploy_config.num_clones) # 3.数据输入、网络计算结果、定义损失并复制模型到clones，添加变量到tensorboard summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES)) # batch_shape：获取的默认队列大小，即上面r的大小 batch_shape = [1] + 3 * [len(ssd_anchors)] update_ops, first_clone_scope, clones = train_tools.deploy_loss_summary(deploy_config, batch_queue, ssd_net, summaries, batch_shape, FLAGS) # 4.定义学习率、优化器 # 初始学习率：0.001 # 终止学习率：0.0001 # 优化器选择：adam with tf.device(deploy_config.optimizer_device()): # 定义学习率和优化器 learning_rate = train_tools.configure_learning_rate(FLAGS, dataset.num_samples, global_step) # 定义优化器 optimizer = train_tools.configure_optimizer(FLAGS, learning_rate) # 观察学习的变化情况添加到summaries中 summaries.add(tf.summary.scalar('learning_rate', learning_rate)) # 5.计算所有GPU/CPU设备的平均损失和每个变量的梯度总和、定义训练OP、summaries OP train_op, summaries_op = train_tools.get_trainop(optimizer, summaries, clones, global_step, first_clone_scope, update_ops) # 6.配置训练的config，进行训练 # 6.1 配置config和saver gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8) config = tf.ConfigProto(log_device_placement=False, # 若果打印会有许多变量的设备信息出现 gpu_options=gpu_options) saver = tf.train.Saver(max_to_keep=5, # 默认保留最近几个模型文件 keep_checkpoint_every_n_hours=1.0, write_version=2, pad_step_number=False) # 6.2 训练 slim.learning.train( train_op, # 训练优化器tensor logdir=FLAGS.train_model_dir, # 模型存储目录 master='', is_chief=True, init_fn=train_tools.get_init_fn(FLAGS), # 初始化参数的逻辑，预训练模型的读取和微调模型判断 summary_op=summaries_op, # 摘要 number_of_steps=FLAGS.max_number_of_steps, # 最大步数 log_every_n_steps=10, # 打印频率 save_summaries_secs=60, # 保存摘要频率 saver=saver, # 保存模型参数 save_interval_secs=600, # 保存模型间隔 session_config=config, # 会话参数配置 sync_optimizer=None) if __name__ == '__main__': tf.app.run()
训练模型：
训练的过程使用技嘉RTX2070Super显卡。
切换到ObjectDetection目录，执行如下命令（参数可以自己设定）：
PRE_TRAINED_PATH=./ckpt/pre_trained/ssd_300_vgg.ckpt TRAIN_MODEL_DIR=./ckpt/fine_tuning/ DATASET_DIR=./IMAGE/tfrecords/commodity_tfrecords/ python train_ssd_network.py --train_model_dir=${TRAIN_MODEL_DIR} --dataset_dir=${DATASET_DIR} --dataset_name="commodity_2018" --train_or_test=train --model_name=ssd_vgg_300 --pre_trained_path=${PRE_TRAINED_PATH} --weight_decay=0.0005 --optimizer=adam --learning_rate=0.001 --batch_size=16
此时可以学习。
同时在ckpt/fine_tuning文件夹下，执行如下命令，可以使用tensorboard查看已经添加到tensorboard中的相关参数。
tensorboard --logdir=./
训练过程如下图所示：
7.测试过程
7.1测试流程
1）测试数据准备
2）preprocessing数据预处理--测试过程的数据预处理就是需要图片的resize
3）模型加载
4）postprocess（预测结果后期处理）--训练过程中是不需要后期处理的
通过scores筛选bbox
使用NMS筛选box
注意bbox边界与原始图片的bbox，按需修改bbox
5）预测结果显示（使用matplotlib）
7.1 测试框架：
其中，test文件夹用于测试使用，visualization.py文件里面是显示结果的代码，test_image.py文件中文最终存放的测试代码。
7.2 测试代码
7.2.1显示图片代码
visualization.py中的显示结果的代码如下：
import cv2 import random import matplotlib.pyplot as plt import matplotlib.image as mpimg import matplotlib.cm as mpcm VOC_LABELS = { '0': 'Background', '1': 'clothes', '2': 'pants', '3': 'shoes', '4': 'watch', '5': 'phone', '6': 'audio', '7': 'computer', '8': 'books' } # =========================================================================== # # Matplotlib 显示图 # =========================================================================== # def plt_bboxes(img, classes, scores, bboxes, figsize=(10,10), linewidth=1.5): """显示bounding boxes. """ fig = plt.figure(figsize=figsize) plt.imshow(img) height = img.shape[0] width = img.shape[1] colors = dict() for i in range(classes.shape[0]): cls_id = int(classes[i]) if cls_id >= 0: score = scores[i] if cls_id not in colors: colors[cls_id] = (random.random(), random.random(), random.random()) ymin = int(bboxes[i, 0] * height) xmin = int(bboxes[i, 1] * width) ymax = int(bboxes[i, 2] * height) xmax = int(bboxes[i, 3] * width) rect = plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, fill=False, edgecolor=colors[cls_id], linewidth=linewidth) plt.gca().add_patch(rect) class_name = str(cls_id) plt.gca().text(xmin, ymin - 2, '{:s} | {:.3f}'.format(VOC_LABELS[class_name], score), bbox=dict(facecolor=colors[cls_id], alpha=0.5), fontsize=12, color='white') plt.show()
7.2.1测试过程代码
测试过程test_image.py代码如下：
import numpy as np import tensorflow as tf from PIL import Image import sys sys.path.append('../') import matplotlib.pyplot as plt import matplotlib.image as mping import visualization from utils.basic_tools import np_methods slim = tf.contrib.slim from nets import nets_factory from preprocessing import preprocessing_factory # 1.定义输入图片数据的占位符 image_input = tf.placeholder(tf.uint8, shape=[None, None, 3]) # 定义输出形状，元组表示 net_shape = (300, 300) data_format = 'NHWC' # 2.数据输入预处理工厂，进行预处理 preprocessing_fn = preprocessing_factory.get_preprocessing('ssd_vgg_300', is_training=False) image_Pre, _, _, bbox_img = preprocessing_fn(image_input, None, None, net_shape, data_format) # image_Pre是三维形状--->(300, 300, 3) # 卷积神经网络要求都是四维的数据计算 # 维度的扩充--->(1, 300, 300, 3) image_4d = tf.expand_dims(image_Pre, 0) # 3.定义SSD模型，并输出预测结果 # 网络工厂获取 ssd_class = nets_factory.get_network('ssd_vgg_300') ssd_params = ssd_class.default_params._replace(num_classes=9) reuse = True if 'ssd_net' in locals() else False # 初始化网络 ssd_net = ssd_class(ssd_params) ssd_anchors = ssd_net.anchors(net_shape) # 通过网络的方法获取结果 # 使用slim指定公有参数 with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)): predictions, localizations, _, _ = ssd_net.net(image_4d, is_training=False, reuse=reuse) config = tf.ConfigProto(log_device_placement=False) sess = tf.InteractiveSession(config=config) sess.run(tf.global_variables_initializer()) ckpt_filepath = '../ckpt/fine_tuning/model.ckpt-103480' saver = tf.train.Saver() saver.restore(sess, ckpt_filepath) # 会话运行图片，输出结束 # 读取一张图片 img = Image.open('../IMAGE/commodity/JPEGImages/000080.jpg').convert('RGB') img = np.array(img) i, p, l, box_img = sess.run([image_4d, predictions, localizations, bbox_img], feed_dict={image_input:img}) # 进行结果筛选 classes, scores, bboxes = np_methods.ssd_bboxes_select( p, l, ssd_anchors, select_threshold=0.5, img_shape=(300, 300), num_classes=9, decode=True ) # bbox边框不能超过原图片，默认原图的相对于bbox大小比例 [0, 0, 1, 1] bboxes = np_methods.bboxes_clip(box_img, bboxes) # 根据 scores 从大到小排序，并改变classes rbboxes的顺序 classes, scores, bboxes = np_methods.bboxes_sort(classes, scores, bboxes, top_k=400) # 使用nms算法筛选bbox classes, scores, bboxes = np_methods.bboxes_nms(classes, scores, bboxes, nms_threshold=.45) # 根据原始图片的bbox，修改所有bbox的范围[.0, .0, .1, .1] bboxes = np_methods.bboxes_resize(box_img, bboxes) visualization.plt_bboxes(img, classes, scores, bboxes)
测试中使用训练得到的ckpt/fine_tuning/model.ckpt-103480文件中的参数进行。测试结果如下图所示：
