【源码解读】YOLO v3 - 06 测试

　　

　　在实际预测的过程中，主要包括两个部分：

• 输入图像的标准化处理
• 从模型输出的y1,y2,y3中进行分类和定位

　　虽然会先生成yolo的对象，即预测评估的运算过程。

 输入图像的处理

def detect_img(yolo):
    path = "VOCdevkit/VOC2007/SegmentationClass/*.jpg"
    outdir = "./VOCdevkit/VOC2007/SegmentationObject"
    for jpgfile in glob.glob(path):
        img = Image.open(jpgfile)
        img = yolo.detect_image(img)   # (731*575)
        img.save(os.path.join(outdir, os.path.basename(jpgfile)))
    yolo.close_session()

　　在代码的第6行yolo.detect_image(img)中对输入的图像进行处理。

def detect_image(self, image):

A. 要获得图像数据image_data：

• 判断设置的输入尺寸是不是能够整除32的，
• 将输入的图片等比缩放至设定的model_image_size的大小中（此处为416*416）

　　-- letterbox_image()中， 过程与y_true的等比缩放的过程相同（详见：https://www.cnblogs.com/monologuesmw/p/12794278.html），放在灰片上也会使图像放置在正中央的位置， 只不过此时没有标定框的事宜。

if self.model_image_size != (None, None):   # 判断是否设定图像输入模型的尺寸范围
    assert self.model_image_size[0] % 32 == 0, 'Multiples of 32 required'    # 这个是关于模型设定的尺寸的大小是否符合规范，
    assert self.model_image_size[1] % 32 == 0, 'Multiples of 32 required'    # 而不是图像的大小（对图像没有要求）
    boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))    # 把输入图像缩放至规定的方位内
else:
    new_image_size = (image.width - (image.width % 32),
                      image.height - (image.height % 32))
    boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype='float32') 

B. 图像数据归一化，并将其维度调整至运算过程中可用的维度

　　扩展数组的形状，在第0维的位置多1维。 即 416*416*3--》1*416*416*3

　　#通过上述的扩展转换，使得输入的尺寸符合网络输入格式 [batch_size, width, high, channels]

image_data /= 255.  # 归一化了
image_data = np.expand_dims(image_data, 0)  # Add batch dimension. 

C. 通过喂数据，获得边框、类别信息

　　该部分的主干在于yolo初始化的generate过程，这个时候返回的检测每个物体的图像仅有一个。（即已经经过了nms等过滤系统）

out_boxes, out_scores, out_classes = self.sess.run(
    [self.boxes, self.scores, self.classes],
    feed_dict={
        self.yolo_model.input: image_data,     # 图像的数据
        self.input_image_shape: [image.size[1], image.size[0]],    # 原始图像的宽高
        K.learning_phase(): 0    # 学习模式， 0： 测试模型， 1： 训练模型
    })     # 该部分的目的在于求解generate的过程，

D. 将获得的边框，类别、类别概率信息绘制在原图上

• 进行字体、厚度的设置

font = ImageFont.truetype(font='font/FiraMono-Medium.otf',
            size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))   # 字体
thickness = (image.size[0] + image.size[1]) // 300  # 厚度

• 按照输出的类别进行循环，并进行绘制

for i, c in reversed(list(enumerate(out_classes))):

　　获得框、类等信息

predicted_class = self.class_names[c]  # 预测的类别
box = out_boxes[i]   # 框信息
score = out_scores[i]   # 框的得分（IOU）

　　获取预测边框的尺寸

top, left, bottom, right = box
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))

　　上、左会+0.5 并且向下取整；

　　下、右会+0.5 并且向下取整，再和原图的宽高对比取最小

print(label, (left, top), (right, bottom))    # 边框坐标

　　根据预测框的位置，调整文本的位置label_size--》[110, 20]

if top - label_size[1] >= 0:   # 101-20>=0
    text_origin = np.array([left, top - label_size[1]])  # 
else:
    text_origin = np.array([left, top + 1])

　　绘制

for i in range(thickness):
    draw.rectangle(
        [left + i, top + i, right - i, bottom - i],
        outline=self.colors[c])
draw.rectangle(
    [tuple(text_origin), tuple(text_origin + label_size)],
    fill=self.colors[c])
draw.text(text_origin, label, fill=(0, 0, 0), font=font)

2. 模型预测

　　始于YOLO()类的初始化。

detect_img(YOLO())

　　关于模型的预测，全系于代码第8行的generate中。

def __init__(self, **kwargs):
    self.__dict__.update(self._defaults)  # set up default values
    self.__dict__.update(kwargs)   # and update with user overrides
    self.class_names = self._get_class()   # 通过路径获取class_names的值
    self.anchors = self._get_anchors()   # 获取边界的宽高， 并将原始数据转化为两列
    self.sess = K.get_session()
    self.boxes, self.scores, self.classes = self.generate()

　　generate内部包含处理的函数如下思维导图所示：

• yolo_head: 将模型最后一层的输出转化为中心点坐标、宽、高、框置信度、类别概率。即那些公式的计算。
• yolo_correct_boxes: 转换成真实图像上的坐标
• yolo_boxes_and_scores:中除了包含两个函数以外，还会进行框的得分的计算：

　　 框的得分=框的置信度*类别置信度

　　并且返回框的信息和框的得分

• yolo_eval：中除了包含上述的函数，还会根据框的得分和阈值进行过滤，并进行NMS抑制被标定多次的框。

　　接下来将从最底层往顶层扒~

A. yolo_head()

def yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):
    """Convert final layer features to bounding box parameters."""

　　获得anchors的个数，并初始化一个相关的张量

num_anchors = len(anchors)
# Reshape to batch, height, width, num_anchors, box_params.
anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])

　　创建网格

　　这个网格用于后续将偏移量转化为每个中心点的坐标。

• 会包含x轴的网格和y轴的网格 两部分
• 每部分每行都是从0到12的网格数
• 最后将其合并在一起，组成了一个13*13*1*2的矩阵

grid_shape = K.shape(feats)[1:3]  # height, width   获取网格的尺寸 eg：13*13
grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),
    [1, grid_shape[1], 1, 1])   # 0~12的 从代码上看，只有grid_shape[1]能够体现reshape的这个功能 一个像素一个格子？
grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),
    [grid_shape[0], 1, 1, 1])   #  用于生成网格grid
grid = K.concatenate([grid_x, grid_y])
grid = K.cast(grid, K.dtype(feats))  #  -》（13,13,1,2）

　　将最后一位展开，网格info与其它分离

feats = K.reshape(
    feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])    

　　进行计算

• 中心点坐标
• 宽高
• 框的置信度
• 类别概率

box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
box_confidence = K.sigmoid(feats[..., 4:5])  # 框置信度
box_class_probs = K.sigmoid(feats[..., 5:])   # 类别置信度    # 可以一次性的把所有网格包含的内容都算出来

中心点的坐标是相对于网格尺寸的位置

宽高是相对于416*416尺寸的位置

B. yolo_correct_boxes()

def yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape):
    '''转化成真实的坐标'''

　　进行坐标的翻转

box_yx = box_xy[..., ::-1]
 box_hw = box_wh[..., ::-1]

　　获得图像经过等比缩放以后的尺寸（没有灰边的）--- new_shape

input_shape = K.cast(input_shape, K.dtype(box_yx))
image_shape = K.cast(image_shape, K.dtype(box_yx))
new_shape = K.round(image_shape * K.min(input_shape/image_shape))

将box的中心点、宽高调整至原图尺寸

offset = (input_shape-new_shape)/2./input_shape
scale = input_shape/new_shape
box_yx = (box_yx - offset) * scale
box_hw *= scale

　　将中心点、宽高信息转化为四个坐标点 xmin ymin xmax ymax

box_mins = box_yx - (box_hw / 2.)
box_maxes = box_yx + (box_hw / 2.)
boxes =  K.concatenate([
    box_mins[..., 0:1],  # y_min
    box_mins[..., 1:2],  # x_min
    box_maxes[..., 0:1],  # y_max
    box_maxes[..., 1:2]  # x_max
])# 即转化为真实坐标
return boxes     ---- 此处的boxes已经是原图上的了  

C. yolo_boxes_and_scores()

def yolo_boxes_and_scores(feats, anchors, num_classes, input_shape, image_shape):
    '''Process Conv layer output'''  处理卷积层输出的结果

　　执行A.和B

box_xy, box_wh, box_confidence, box_class_probs = yolo_head(feats,
    anchors, num_classes, input_shape)
boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)
boxes = K.reshape(boxes, [-1, 4])

　　计算框的得分

　　 框的得分=框的置信度*类别概率

box_scores = box_confidence * box_class_probs   # 框的得分=框的置信度*类别置信度
box_scores = K.reshape(box_scores, [-1, num_classes])
return boxes, box_scores   --- 原图上的boxes  而且是四坐标

D. yolo_eval()

def yolo_eval(yolo_outputs,     # 网络神经元输出的feature map（last layer）
              anchors,
              num_classes,
              image_shape,
              max_boxes=20,
              score_threshold=.6,
              iou_threshold=.5):
    """Evaluate YOLO model on given input and return filtered boxes."""

　　相关使用的信息初始化：

num_layers = len(yolo_outputs)
anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32      # 模型最后一层有三个神经元---> (32,16,8)13-26-52  （下采样的时候的尺度缩放）
boxes = []                                            # 每个神经元会有3个anchor_box
box_scores = []

　　input_shape 为 416*416的；

　　逐层获得的边框信息和框的分的信息：

for l in range(num_layers):
    _boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
        anchors[anchor_mask[l]], num_classes, input_shape, image_shape)   # 处理卷积层的输出 内含yolo_head
    boxes.append(_boxes)
    box_scores.append(_box_scores)    # 

　　将boxes 和 box_scores的数据展平：

boxes = K.concatenate(boxes, axis=0)   # 将数据展平 (?,4)---四坐标（与标定一样）
box_scores = K.concatenate(box_scores, axis=0)

　　获得了一个边界框的得分是否大于阈值的布尔向量，用于将低于阈值的边界框过滤掉

mask = box_scores >= score_threshold     # 对三种尺度的得分进行筛选（阈值） 得到一堆符合条件的布尔值

　　初始化：

max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []

　　按类进行进一步的框框筛选：

for c in range(num_classes):

　　过滤掉一些得分小于阈值的边框：

class_boxes = tf.boolean_mask(boxes, mask[:, c])   # 过滤掉一些得分小于阈值的边界框
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])

　　进行NMS处理（处理掉标定同一物体的多个标定的框）

nms_index = tf.image.non_max_suppression(
    class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)  # 运行非最大抑止—用于排出同一目标被标注多次的框

 

class_boxes = K.gather(class_boxes, nms_index)   # 在class_boxes中搜寻nms_index下表的向量
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c  
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)

 

　　从此结束循环

boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_

　　generate中包含导入模型以及给不同的类分配一种颜色的框，然后就是yolo_eval().