yolov3 正向传播解析
yolov3是用于物品实时检测分类的一个算法，博客也搭建完成了，先来做个正向传播的总结。
本代码使用keras，感觉比较简单，哈哈
模型数据是直接下载yolov3官网的权重，然后转换成keras能够加载的.h5模型的。
参考的github网址：https://github.com/qqwweee/keras-yolo3
此代码的正向传播是全卷积神经网络，一共有三个输出dense，嗯，就是三个大方块，但他们都叫dense，密度？仿佛是个**，好吧是我英语太菜了
先给你看看yolov3的直观图像： yolov3图像
太长了，我写成了一个链接，一共有三个输出
13*13*3*85
26*26*3*85
52*52*3*85
这三个结果分别是对应的三个不同大小的滑动窗口全卷积跑下来的结果。
滑动窗口原指使用一个检测物品的固定大小的一个窗口，从图像的左上角一直遍历到图像的右下角，从而检测整个图像中所有可能存在物品的位置。
但是使用全卷积的滑动窗口，就可以一次性将所有位置检测完毕。
不懂的话可以先看看我的另一篇卷积神经网络学习笔记的介绍。
该预测方法，被包装成了一个类。
首先在初始化该类的时候，使用keras的load_model加载yolov3的模型。
设置对应的阈值。
然后使用predict函数进行预测。
predict函数，使用模型和要处理的图片进行一次正向传吧，得到输出的三个feature（特征结果）。
大小分别是
13*13*3*85
26*26*3*85
52*52*3*85
之后再使用mask，anchor box和非最大抑制处理一下，得到最终的物品的boxes和classes，和scores，分别是对应物品的box和类别和自信度。
下面给出正向传播的代码，结合论文阅读更易理解哦！ yolov3论文：https://pjreddie.com/media/files/papers/YOLOv3.pdf
"""YOLO v3 output
"""
import numpy as np
import keras.backend as K
from keras.models import load_model
class YOLO:
#加载数据模型yolo.h5
def __init__(self, obj_threshold, nms_threshold):
"""Init.
# Arguments
obj_threshold: Integer, threshold for object.
nms_threshold: Integer, threshold for box.
"""
self._t1 = obj_threshold
self._t2 = nms_threshold
self._yolo = load_model('data/yolo.h5')
def _sigmoid(self, x):
"""sigmoid.
# Arguments
x: Tensor.
# Returns
numpy ndarray.
"""
return 1 / (1 + np.exp(-x))
# 处理yolo正向传播跑出来的结果
def _process_feats(self, out, anchors, mask):
"""process output features.
# Arguments
out: Tensor (N, N, 3, 4 + 1 +80), output feature map of yolo.
anchors: List, anchors for box.
mask: List, mask for anchors.
# Returns
boxes: ndarray (N, N, 3, 4), x,y,w,h for per box.
box_confidence: ndarray (N, N, 3, 1), confidence for per box.
box_class_probs: ndarray (N, N, 3, 80), class probs for per box.
"""
# 获取格子的大小和box的数量
grid_h, grid_w, num_boxes = map(int, out.shape[1: 4])
# 获取对应要使用的anchors
anchors = [anchors[i] for i in mask]
# 调整anchors的大小
# 本来anchors是[[116, 90], [156, 198], [373, 326]] [[30, 61], [62, 45], [59, 119]] [[10, 13], [16, 30], [33, 23]]
anchors_tensor = np.array(anchors).reshape(1, 1, len(anchors), 2)
# 调整后[[[[116 90][156 198][373 326]]]]，你问我这是要干嘛？我也不知道
# Reshape to batch, height, width, num_anchors, box_params.
out = out[0]
# 去掉了out的第一维
# (13, 13, 3, 85)
# (26, 26, 3, 85)
# (52, 52, 3, 85)
# 使用sigmoid激活函数，将所有值收敛到0-1之间
# 可知out现在是13*13*3*85
# 最后的85是y，y=[x,y,w,h,fc,c1,c2....c80]
# [...,:2]意思是取最后一维的前两个数即 out[...,0]和out[...,:1]即x，y
# box_xy的shape为(13*13*3*2)即所有的xy
box_xy = self._sigmoid(out[..., :2])
# 同理取wh，但是都求了e的wh次方，因为论文中的公式是这个，但是取e是为了？
box_wh = np.exp(out[..., 2:4])
# 由于正向传播过来的box的大小都是在0-1之间的，是百分比，不是真实值，我们将其还原为真实值
# 可知box_wh的形状是13*13*3*2,anchors_tensor的形状是1*1*3*2，由于类型是np.array所以是对应位置相乘
# 相乘的结果是(13, 13, 3, 2)，即全部的wh都还原成为了真实大小，相对于416*416而说的
box_wh = box_wh * anchors_tensor
# 取fc,每个预测的自信度，首先使用sigmoid归一化到0-1之间
box_confidence = self._sigmoid(out[..., 4])
# 可知box_confidence的形状现在是13*13*3
# 扩展在最后扩展一维成为13*13*3*1
box_confidence = np.expand_dims(box_confidence, axis=-1)
# 取分类,可知box_class_probs的形状为13*13*3*80
box_class_probs = self._sigmoid(out[..., 5:])
# np.tile，tile是瓷砖的意思，就是把地方给铺开，
# 如tile(0, (3, 4))
# 即把0铺3行4列
# [[0 0 0 0]
# [0 0 0 0]
# [0 0 0 0]]
col = np.tile(np.arange(0, grid_w), grid_w).reshape(-1, grid_w)
# col会被铺成如下的形状
# (13, 13) [[ 0 1 2 3 4 5 6 7 8 9 10 11 12],.....], 每一行都是0-12，一共铺12行
# (26, 26)
# (52, 52)
row = np.tile(np.arange(0, grid_h).reshape(-1, 1), grid_h)
# row会被铺成如下的形状
# (13, 13) [[ 0 0 0 0 0 0 0 0 0 0 0 0 0], [ 1 1 1 1 1 1 1 1 1 1 1 1 1],.....]
# 第一行13个0，第二行13个1，...
# (26, 26)
# (52, 52)
# reshape 为(13, 13, 3, 1)
col = col.reshape(grid_h, grid_w, 1, 1).repeat(3, axis=-2)
row = row.reshape(grid_h, grid_w, 1, 1).repeat(3, axis=-2)
# grid 的形状为(13, 13, 3, 2)
grid = np.concatenate((col, row), axis=-1)
# grid是一个大方块为13*13*3*2的两个大方块，里面的数字排列情况请自行脑部，好难描述呀
# 大致就是col是从左到右是一面数字0，一面数字1，一面数字2
# 而row是从上到下是一面数字0，一面数字1，一面数字2，然后拼在一起
# box_xy+=grid不知道是个啥操作？？？？
# box_xy是13*13*3*2，grid是13*13*3*2
# 可知其中每一个xy都是相对当前格子的xy，并不是对于整个图像的xy，整体图像一公分被分为了13份
# 那么我们从图像的最左边的那个格子开始，逐个加一，不就是每个xy相对于整个图像的位置了嘛
# 所以这也解释了为什么，第一幅col是从左到右逐个加一，第二幅图像row是从上到下逐个加一。
# 因为第一个是加x，x是从图像的左边到右边逐个加一，y是从图像的上方到下方逐个加一。
box_xy += grid
# 然后让每一个xy相对整个图像归一化
box_xy /= (grid_w, grid_h)
# 归一化wh的值，因为预测出来的是0-416的值，
# 但是我们等会儿要用原来图像的大小进行计算真是的wh，然后画到原图像上
box_wh /= (416, 416)
# 算出来图像的左上角？？？
box_xy -= (box_wh / 2.)
# 把就算的结果合并到一起
boxes = np.concatenate((box_xy, box_wh), axis=-1)
return boxes, box_confidence, box_class_probs
# 过滤bounding box
# boxes是归一化过后的bexes包含x，y，w，h
# box_confidences是指的pc，box_class_prob指的是类别
def _filter_boxes(self, boxes, box_confidences, box_class_probs):
"""Filter boxes with object threshold.
# Arguments
boxes: ndarray, boxes of objects.
box_confidences: ndarray, confidences of objects.
box_class_probs: ndarray, class_probs of objects.
# Returns
boxes: ndarray, filtered boxes.
classes: ndarray, classes for boxes.
scores: ndarray, scores for boxes.
"""
# np.shape(box_confidences) (13, 13, 3, 1)
# np.shape(box_class_probs) (13, 13, 3, 80)
# np.shape(box_scores) (13, 13, 3, 80)
box_scores = box_confidences * box_class_probs
# np.shape(box_scores) (13, 13, 3, 80)
# box_classes 是所有类别的最大自信度的那个的类别
# 比如13*13这个，那么每个后边都有80个分类，box_classes就是这80个中最大的那个类别的序号
# np.shape(box_classes) (13, 13, 3)
box_classes = np.argmax(box_scores, axis=-1)
# np.shape(box_class_scores) (13, 13, 3)
box_class_scores = np.max(box_scores, axis=-1)
# box_classes 指的是80类中最大值的那个类别的序号
# box_class_scores 指的是80类中最大值的那个类别的数值
# 找出所有大于阈值的box
pos = np.where(box_class_scores >= self._t1)
# 把符合条件的box都返回
boxes = boxes[pos]
classes = box_classes[pos]
scores = box_class_scores[pos]
return boxes, classes, scores
# 非最大抑制
def _nms_boxes(self, boxes, scores):
"""Suppress non-maximal boxes.
# Arguments
boxes: ndarray, boxes of objects.
scores: ndarray, scores of objects.
# Returns
keep: ndarray, index of effective boxes.
"""
x = boxes[:, 0]
y = boxes[:, 1]
w = boxes[:, 2]
h = boxes[:, 3]
areas = w * h
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x[i], x[order[1:]])
yy1 = np.maximum(y[i], y[order[1:]])
xx2 = np.minimum(x[i] + w[i], x[order[1:]] + w[order[1:]])
yy2 = np.minimum(y[i] + h[i], y[order[1:]] + h[order[1:]])
w1 = np.maximum(0.0, xx2 - xx1 + 1)
h1 = np.maximum(0.0, yy2 - yy1 + 1)
inter = w1 * h1
ovr = inter / (areas[i] + areas[order[1:]] - inter)
inds = np.where(ovr <= self._t2)[0]
order = order[inds + 1]
keep = np.array(keep)
return keep
# 将正向传播后的结果和原图像的大小传过来
def _yolo_out(self, outs, shape):
"""Process output of yolo base net.
# Argument:
outs: output of yolo base net.
shape: shape of original image.
# Returns:
boxes: ndarray, boxes of objects.
classes: ndarray, classes of objects.
scores: ndarray, scores of objects.
"""
# 定义的几个masks还有anchors，但是为啥是在这里，现在才要跑滑动窗口？
# masks的意思是挑选哪几个anchor box使用，分别对应了不同大小的anchor box
# 他分了三组
masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
anchors = [[10, 13], [16, 30], [33, 23], [30, 61], [62, 45],
[59, 119], [116, 90], [156, 198], [373, 326]]
boxes, classes, scores = [], [], []
# outs一共包含三张feature
# (1, 13, 13, 3, 85)
# (1, 26, 26, 3, 85)
# (1, 52, 52, 3, 85)
# 13*13 一共划分了169个格子，然而图像是416*416
# 所以对应的每一个格子都应该大一点，这样才能够尽可能的检测到图像中的每一个位置。
# 同理，当处理26*26的时候，由于本身划分的格子就更多了，所以每个格子的大小就可以小一点，这样也不会漏掉位置
# 这样的检测有助于我们同时检测到大物品和小物品。
# 对于三张不同的feature使用不同大小的anchor box进行预测
for out, mask in zip(outs, masks):
# 处理一个feature，就是归一化，让后返回回来，emmmmm
b, c, s = self._process_feats(out, anchors, mask)
# 对feature进行过滤，在每个格子出挑选出最大自信度的那个类别，并且去除不达到阈值的
b, c, s = self._filter_boxes(b, c, s)
boxes.append(b)
classes.append(c)
scores.append(s)
boxes = np.concatenate(boxes)
classes = np.concatenate(classes)
scores = np.concatenate(scores)
# 放缩box到原来的大小，因为现在都是归一化后的数值
# Scale boxes back to original image shape.
width, height = shape[1], shape[0]
image_dims = [width, height, width, height]
boxes = boxes * image_dims
nboxes, nclasses, nscores = [], [], []
for c in set(classes):
inds = np.where(classes == c)
b = boxes[inds]
c = classes[inds]
s = scores[inds]
# 算非最大抑制
keep = self._nms_boxes(b, s)
nboxes.append(b[keep])
nclasses.append(c[keep])
nscores.append(s[keep])
if not nclasses and not nscores:
return None, None, None
boxes = np.concatenate(nboxes)
classes = np.concatenate(nclasses)
scores = np.concatenate(nscores)
return boxes, classes, scores
# 预测，把处理过的图像(调整了大小为416*416和4个channel)传过来了(1, 416, 416, 3)，还有原图像的大小(？，？，3)
def predict(self, image, shape):
"""Detect the objects with yolo.
# Arguments
image: ndarray, processed input image.
shape: shape of original image.
# Returns
boxes: ndarray, boxes of objects.
classes: ndarray, classes of objects.
scores: ndarray, scores of objects.
"""
# 使用predict函数对标准图像进行预测
# _yolo 是加载的yolov3的模型
# _yolo.predict(image)就是在keras的帮助下，使用image这张图像正向传播一边
# 使用加载的yolo.h5模型，进行正向传播，得到输出结果
# outs一共包含三张feature
# (1, 13, 13, 3, 85)
# (1, 26, 26, 3, 85)
# (1, 52, 52, 3, 85)
outs = self._yolo.predict(image)
# 根据输出的三张feature，使用mask和anchor box，还有非最大抑制来处理一下这个输出，
# 最终得到物品的boxes和对应的类别，和对应的自信度。
# 根据原图像的大小调整输出
boxes, classes, scores = self._yolo_out(outs, shape)
return boxes, classes, scores