使用google object_detection API检测重力波

在之前的文章中，我已经介绍了tensorflow框架的安装和virtual env下使用的方法。下面这篇博文即是我的毕业设计的项目，同时也是我在学习了机器学习和tensorflow框架一段时间后做的第一个实战。所以大家可以放心的是这篇文章将是平易近人的，不会有太多算法上的介绍（关于这里我使用的网络结构我将在网络结构和算法分析的tag里给大家做详细的介绍）。

项目的简单介绍

大家如果看过我blog的about，应该知道我是一名学习物理相关的学生。我的毕业设计主要是从卫星图像中自动检测重力波。这里读者并不需要知道重力波的具体含义，只需要有一个大体的概念，在卫星图像中大气重力波大概是这样的：

这样的重力波结构解释我们需要在图像中自动识别出来的目标，下面的内容就是如何使用object detection将它识别出来。

tensorflow object detection API的简单介绍

其实熟悉tensorflow的人应该都知道，tensorflow在github上的主页是：tensorflow，这个主页下面有两个比较重要的repo（可以参照star的数量），分别是Tensorflow的源代码repo：tensorflow/tensorflow，另一个就是我们今天要介绍的tensorflow/models。后者tensorflow/models是Google官方用TensorFlow做的各种实例，对于我们今天这个实践题目比较重要的就是图像分类的Slim。尤其是对于我们现在这个任务，前面必须有一个像样的ImageNet图像分类模型来充当所谓的特征提取（feature extraction）层，比如VGG6、ResNet等网络结构。tensorflow官方实现这些网络结构的项目是tensorflow Slim，而object detection API正是基于slim的，这个库的公布时间比较早，内容也相对丰富和成熟。下面我就从安装到训练再到预测给大家做详细的说明讲解。

tensorflow/models的安装

首先我们可以参考github上models repo的安装建议：
首先是库依赖情况：

• Protobuf 3+
• Python-tk （这个库在后面做图的时候可能会与Matplotlib由backend的冲突所以要留意一下）
• Pillow 1.0
• lxml（为了识别我们数据集使用的pascal VOC格式数据，一定要安装这个依赖库）
• Slim（这个库已经包含在tenorflow/models/ersearch/里面，只需要一个指令就可以指定Slim抽取了）
• jupyter notebook（方便的可视化python编程工具，提供良好的交互界面，在编程环境目录的博文中我还会介绍如何使用anaconda3+jupyter实现远程操作）
• Matplotlib（画图库，不解释）
• tensorflow
• cython
• cocoapi

如果您的机器上还没有安装tensoflow的话，请参考我之前的博文进行tensorflow的安装。下面是如何安装上面这些依赖库的介绍（本机环境ubuntu16.04+python3.5.2 使用virtual env）：

sudo apt-get install protobuf-compiler python-pil python-lxml python-tk
sudo pip install Cpython
sudo pip install jupyter
sudo pip install matplotlib

当然，如果您的机器不是ubuntu或者debian这样使用apt作包管理的系统，那么也可以选择直接用pip安装（在大陆下载速度慢的情况可以通过加-i flag使用清华镜像解决）：

sudo pip install Cython
sudo pip install pillow
sudo pip install lxml
sudo pip install jupyter
sudo pip install matplotlib

这里由于我的模型没有用到COCO API所以没有安装COCO库，大家如果感兴趣的话可以直接去github上clone COCO下来玩。
在完成了上面的依赖库安装之后，我们直接将github上的models库clone下来，cd目录到tensorflow/models/research 并在目录下执行python安装：

python setup.py build
python setup.py install

另外需要在tensorflow/models/research中编译protobuf libraries，这是因为我们使用的object detection API要使用protobuf来编译模型并训练参数。如果您的机器中没有安装protobuf，请先编译安装，如果安装后有报错(关于报错的原因我还不是很清楚，如果您知道的话，请不吝赐教)：

object_detection/protos/anchor_generator.proto:11:3:  Expected “required”, “optional”, or “repeated”.
object_detection/protos/anchor_generator.proto:11:32: Missing field number. 

解决方式是下载protobuf编译后的文件下载地址，解压压缩包到tensorfolw的protoc_3.3文件夹后进入到解压缩文件的bin文件夹

cd bin/
pwd(这一步是为了记住你的bin文件夹全地址)
cd ...你的tenforflow地址.../models/
/home/gabrielsun/tensorflow/protoc3.3/bin/protoc objecr_detection/protos/*.proto --python_out=.

这样一般就可以成功在research文件夹中成功编译protobuf了。如果还有问题可以在我评论区下留言。
下面我们需要指定使用slim做目标识别，这里值得注意的是如果您不将下面这行代码写入到~/.bashrc文件中的话，那么每新建一个terminal都需要在research文件夹下执行下面的代码：

export PYTHONPATH=$PYTHONPATH:`pwd`:`pwd`/slim 

最后测试是否安装编译好：

 python object_detection/builders/models_builder_test.py

如果输出有OK即测试通过。
这样我们的安装部分已经结束了！主要的编程环境也已经搭建好了，下面我们讨论数据集构建的问题。

数据集的制作

这个部分实际上我我在之前毕业设计的开题中没有好好考虑的部分，可能这也是导致我后来在这个部分花了很大的时间精力。这里简单的说明一下。我的想法是利用图像数据做目标检测，所以如何标记图像是一个很大的问题。我采用的标记方式与imagenet上图像数据集标记方式相同—pascal VOC格式。这个格式主要包括了：

• Images文件夹 （包含训练图片和测试图片，混放在一起）
• Annatations文件夹 （xml格式的标签文件）
• Images set文件夹（在这次的项目中没有用到）

由于我的卫星图像要现在NOAA网站上下载HDF5原始格式的文件，然后再写代码画图（由于波段的问题还要调节对比度，不过我比较偷懒我将hdf5中的radiance数值乘了10^9），再将灰度图像转化为3通道图像（记住tensorflow的object_detection库一般只能做3通道图像的训练工作，当然您也可以自己写model完成灰度图像的训练），这样的过程不是每个人都有必要做的，所以我建议如果只是为了尝试训练的话，可以自己写一个爬虫在网上爬下一些图像数据，或者使用相关视频做间隔截图做我们的训练数据就好了。
附上一个截图代码给大家：

import cv2
cap = cv2.VIdeoCapture(“video.mp4”)
c = 1
timef = 100 	#每100帧保存一张图像
while True;
    rval,frame = cap.read()
    if(c % timef == 0):
		print(‘tot=’,tot)
		cv2imwrite(‘out/‘+str(tot).zfill(6)+’.jpg’,frame)		
        tot = tot +1
	c+=1
	cv2.waitKey(1)
cap.release()

这样我们的images文件夹的内容就大概准备好了，接下来解释图像标注的工作也就是要搞定annotations文件夹的内容，这里我的方案是使用labelImg做标注，大家可以直接在github上搜索labelImg，这是一个图形化的图像标记工具，并且可以使用bounding box在图片中标注目标。下面说明一种最简单的安装方式：
确认是否已经安装了需要的依赖库，并直接安装，我的环境是ubuntu16.04 python3+Qt5，先将github repo clone到本地，然后执行：

sudo apt-get install pyqt-dev-tools
sudo pip3 install lxml
python3 labelImg.py

然后就是较为漫长的使用GUI界面进行标注，注意在标注之前选定好annotations存储的目录。我们可以看到生成的xml文件大概张这个样子：

<annotation>
	<folder>images</folder>
	<filename>0032.png</filename>
	<path>/home/gabrielsun/Desktop/images/0032.png</path>
	<source>
		<database>Unknown</database>
	</source>
	<size>
		<width>651</width>
		<height>520</height>
		<depth>1</depth>
	</size>
	<segmented>0</segmented>
	<object>
		<name>waves</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>204</xmin>
			<ymin>170</ymin>
			<xmax>317</xmax>
			<ymax>291</ymax>
		</bndbox>
	</object>
	<object>
		<name>waves</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>355</xmin>
			<ymin>274</ymin>
			<xmax>423</xmax>
			<ymax>466</ymax>
		</bndbox>
	</object>
	<object>
		<name>waves</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>489</xmin>
			<ymin>168</ymin>
			<xmax>587</xmax>
			<ymax>298</ymax>
		</bndbox>
	</object>
	<object>
		<name>waves</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>290</xmin>
			<ymin>68</ymin>
			<xmax>427</xmax>
			<ymax>161</ymax>
		</bndbox>
	</object>
</annotation>

但是我们这样的pascal VOC格式的数据集是不能直接被object detection API所使用的，要先将数据转化成TFrecord格式。TFrecord文件是一种二进制文件，能更好的利用内存，更方便的复制和移动，并且不需要单独的标记文件，附上转换代码：

import os
import io
import xml.etree.ElementTree as ET
import tensorflow as tf

from object_detection.utils import dataset_util
from PIL import Image


flags = tf.app.flags
flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
flags.DEFINE_string('images_dir', '', 'Path to directory of images')
flags.DEFINE_string('labels_dir', '', 'Path to directory of labels')
FLAGS = flags.FLAGS


def create_tf_example(example):

    image_path = os.getcwd() + '/' + FLAGS.images_dir + example
    labels_path = os.getcwd() + '/' + FLAGS.labels_dir + 
        os.path.splitext(example)[0] + '.xml'

    # Read the image
    img = Image.open(image_path)
    width, height = img.size
    img_bytes = io.BytesIO()
    img.save(img_bytes, format=img.format)

    height = height
    width = width
    encoded_image_data = img_bytes.getvalue()
    image_format = img.format.encode('utf-8')

    # Read the label XML
    tree = ET.parse(labels_path)
    root = tree.getroot()
    xmins = xmaxs = ymins = ymaxs = list()

    for coordinate in root.find('object').iter('bndbox'):
        xmins = [int(coordinate.find('xmin').text) / width]
        xmaxs = [int(coordinate.find('xmax').text) / width]
        ymins = [int(coordinate.find('ymin').text) / height]
        ymaxs = [int(coordinate.find('ymax').text) / height]

    classes_text = ['waves'.encode('utf-8')]
    classes = [1]

    tf_example = tf.train.Example(features=tf.train.Features(feature={
        'image/height': dataset_util.int64_feature(height),
        'image/width': dataset_util.int64_feature(width),
        'image/filename': dataset_util.bytes_feature(encoded_image_data),
        'image/source_id': dataset_util.bytes_feature(encoded_image_data),
        'image/encoded': dataset_util.bytes_feature(encoded_image_data),,
        'image/format': dataset_util.bytes_feature(image_format),
        'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),
        'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),
        'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),
        'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),
        'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
        'image/object/class/label': dataset_util.int64_list_feature(classes),
    }))
    return tf_example


def main(_):
    writer = tf.python_io.TFRecordWriter(FLAGS.output_path)

    for filename in os.listdir(FLAGS.images_dir):
        tf_example = create_tf_example(filename)
        writer.write(tf_example.SerializeToString())

    writer.close()


if __name__ == '__main__':
    tf.app.run()

运行:

python3 convert_labels_to_tfrecords.py  
--output_path=train.record  
--images_dir=path/to/your/training/images/ 
--labels_dir=path/to/your/training/label/xml/

这样training set的数据就已经转化为tfrecord格式了，再如法炮制将validation set的images和annotations转化为tfrecord并命名为val.record。这样我们的数据集就算是准备好了。

模型的训练和预测

在research目录下新建2018420目录作为我们的工作目录，如此命名主要是为了日后的版本管理方便。将之前生成的两个tfrecord文件放入到这个目录。另外将object_detection/data/pet_label_map.pbtxt,object_detection/samples/configs/faster_rfcnn_resnet152_pets.config这两个文件也copy到这个目录中。
我们不能直接使用config文件中的设置，要根据自己的情况进行调节。调节的超参数包括steps，learning rate等等。另外还要调节IO的文件地址。在我实践的过程中，我发现fine_tune_checkpoint的设置最好是空的，或者将from_detection_checkpoint参数设置为false。
接下来我们就可以开始训练了。先将目录切换到research文件夹下，然后执行:

python3 object_detection/train.py  
--logtostderr  
-- pipeline_config_path=‘./20180420/faster_rcnn_resnet152_pets.config’ 
--train_dir=‘./20180420/

这样正常情况下我们的训练过程就可以开始了。不过我在实际操作的过程中发现python3.5.2下安装tensorflow可能会出现bytes object与string转换的错误，这实际上是python2和python3在对字符运算上的不一致导致的。python2的string运算是将string先转化为bytes object在做运算，但是python3实际上是对string直接运算的，这里就需要我们在相关的代码中加入try、except了。不过我在加了相关的try、expect仍然会报错，而且错误栈实在是太长了，所以我偷了个懒，换了一种方法，直接使用python2下安装的tensorflow，使用anaconda可以直接转换tensorflow使用python>解释器的版本～

让我们先看看运行结果：

在运行训练程序结束后可以使用tensorboard将训练的过程可视化出来：

后面我们也可以选择对训练好的网络进行评估：

python3 object_detection/eval.py  
--logtostderr 
--pipeline_config_path=‘./20180420/faster_rcnn_resnet152_pets.config’  
--checkpojint_dir=‘./20180420‘
--eval_dir=‘./20180420’ 

在结尾之前我再稍稍讲一下模型的存储和加载，tensorflow提供了两种方式来储存和加载模型：
1.生成检查点文件（checkpoint file），扩展名一般是.ckpt，通过在tf.train_saver对象上调用Saver.save()生成。它包含权重和其他在程序中定义的变量，不包含图结构。如果需要在另一个程序中使用，需要重新创建图形结构，并告诉tensorflow如何处理权重。
2.生成图协议文件（graph proto file）,扩展名一般是.pb，这是一个二进制文件。用tf.train.write_graph()保存，只包含图结构，不包含权重，然后使用tf.import_graph_def()来加载图形。
也就是说模型存储和图存储两者是互为补充的，如果我们要建立一个检测算法的话，就不能不将模型取出并读取到我的检测代码中。这样我们可以介绍一下，生成模型.pb文件的方法：

python3 object_detection/export_inference_graph.py  
--input_type image_tensor
--pipeline_config_path=./2018420/faster_rcnn_resnet152_pets.config
--trained_checkpoint_prefix=./2018420/model.ckpt-1812 
--output_directory=./2018420/output_inference_graph 

附上我的预测代码：

import numpy as np
import os
import six.moves.urllib as urllib
import sys
import tarfile
import tensorflow as tf
import zipfile

from collections import defaultdict
from io import StringIO
# from matplotlib import pyplot as plt ### CWH
from PIL import Image

# if tf.__version__ != '1.4.0':
#   raise ImportError('Please upgrade your tensorflow installation to v1.4.0!')

# ENV SETUP  ### CWH: remove matplot display and manually add paths to references
'''
# This is needed to display the images.
%matplotlib inline
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
'''

# Object detection imports

from object_detection.utils import label_map_util  # CWH: Add object_detection path

# from object_detection.utils import visualization_utils as vis_util ### CWH: used for visualization

# Model Preparation

# What model to download.
# MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17'
# MODEL_FILE = MODEL_NAME + '.tar.gz'
# DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'

# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_CKPT = '/home/gabrielsun/tensorflow_python2.7/models/research/2018422/output_inference_graph/frozen_inference_graph.pb'

# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('/home/gabrielsun/tensorflow_python2.7/models/research/2018422',
                              'pet_label_map.pbtxt')  # CWH: Add object_detection path

NUM_CLASSES = 1


# Download Model
# opener = urllib.request.URLopener()
# opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE)
# tar_file = tarfile.open(MODEL_FILE)
# for file in tar_file.getmembers():
#   file_name = os.path.basename(file.name)
#   if 'frozen_inference_graph.pb' in file_name:
#     tar_file.extract(file, os.getcwd())


# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
  od_graph_def = tf.GraphDef()
  with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
    serialized_graph = fid.read()
    od_graph_def.ParseFromString(serialized_graph)
    tf.import_graph_def(od_graph_def, name='')

# Loading label map
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
    label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)


# Helper code
def load_image_into_numpy_array(image):
  (im_width, im_height) = image.size
  return np.array(image.getdata()).reshape(
      (im_height, im_width, 3)).astype(np.uint8)


# Detection
# For the sake of simplicity we will use only 2 images:
# image1.jpg
# image2.jpg
# If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS.
PATH_TO_TEST_IMAGES_DIR = '/home/gabrielsun/Documents/Graduation_Design/code_and_data/dataset_train/images/'  # cwh
TEST_IMAGE_PATHS = [os.path.join(
    PATH_TO_TEST_IMAGES_DIR, '00{}.png'.format(i)) for i in range(45, 46)]

# Size, in inches, of the output images.
IMAGE_SIZE = (12, 8)

with detection_graph.as_default():
  with tf.Session(graph=detection_graph) as sess:
    # Definite input and output Tensors for detection_graph
    image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
    # Each box represents a part of the image where a particular object was detected.
    detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
    # Each score represent how level of confidence for each of the objects.
    # Score is shown on the result image, together with the class label.
    detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
    detection_classes = detection_graph.get_tensor_by_name(
        'detection_classes:0')
    num_detections = detection_graph.get_tensor_by_name('num_detections:0')
    for image_path in TEST_IMAGE_PATHS:
      image = Image.open(image_path)
      # the array based representation of the image will be used later in order to prepare the
      # result image with boxes and labels on it.
      image_np = load_image_into_numpy_array(image)
      # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
      image_np_expanded = np.expand_dims(image_np, axis=0)
      # Actual detection.
      (boxes, scores, classes, num) = sess.run(
          [detection_boxes, detection_scores, detection_classes, num_detections],
          feed_dict={image_tensor: image_np_expanded})

      # CWH: below is used for visualizing with Matplot
      '''
      # Visualization of the results of a detection.
      vis_util.visualize_boxes_and_labels_on_image_array(
          image_np,
          np.squeeze(boxes),
          np.squeeze(classes).astype(np.int32),
          np.squeeze(scores),
          category_index,
          use_normalized_coordinates=True,
          line_thickness=8)
      plt.figure(figsize=IMAGE_SIZE)
      plt.imshow(image_np)  
      '''

      # CWH: Print the object details to the console instead of visualizing them with the code above

      classes = np.squeeze(classes).astype(np.int32)
      scores = np.squeeze(scores)
      boxes = np.squeeze(boxes)
      # print(scores)
      threshold = 0.20  # CWH: set a minimum score threshold of 50%
      obj_above_thresh = sum(n > threshold for n in scores)

      print("detected %s objects in %s above a %s score" %
            (obj_above_thresh, image_path, threshold))
      for c in range(0, len(classes)):
        if scores[c] > threshold:
          class_name = category_index[classes[c]]['name']
          print(" object %s is a %s - score: %s, location: %s" %
                (c, class_name, scores[c], boxes[c]))

总结一下这次时间的过程，这次实践实际上难点是在程序执行环境的配置上，对于训练算法的应用不是很明显。所以我会在后面的blog中弥补这些内容。另外我也由于这次的机会找到了一个难得的源代码学习的途径—-就是google的object detection API。首先，它是在适应工程的基础上高度标准化的，对于只接触过ML皮毛的人来说这也可以靠修改网络的config文件进行得心应手的训练。另外由于google在云端计算上的突出表现我们的计算过程也是可以放在cloud上进行的，而且这样的过程也是可视化的，并且我们的关注点将更少的放在系统层甚至是硬件问题上，更多的是去讨论算法上的核心问题。
好了，这次的实践内容告一段落，有问题可以在评论区找到我哦～