文章目录[隐藏]
YOLOv3学习之锚框和候选区域
单阶段目标检测模型YOLOv3
R-CNN系列算法需要先产生候选区域，再对候选区域做分类和位置坐标的预测，这类算法被称为两阶段目标检测算法。近几年，很多研究人员相继提出一系列单阶段的检测算法，只需要一个网络即可同时产生候选区域并预测出物体的类别和位置坐标。
与R-CNN系列算法不同，YOLOv3使用单个网络结构，在产生候选区域的同时即可预测出物体类别和位置，不需要分成两阶段来完成检测任务。另外，YOLOv3算法产生的预测框数目比Faster R-CNN少很多。Faster R-CNN中每个真实框可能对应多个标签为正的候选区域，而YOLOv3里面每个真实框只对应一个正的候选区域。这些特性使得YOLOv3算法具有更快的速度，能到达实时响应的水平。
Joseph Redmon等人在2015年提出YOLO（You Only Look Once，YOLO）算法，通常也被称为YOLOv1；2016年，他们对算法进行改进，又提出YOLOv2版本；2018年发展出YOLOv3版本。
YOLOv3模型设计思想
YOLOv3算法的基本思想可以分成两部分：
- 按一定规则在图片上产生一系列的候选区域，然后根据这些候选区域与图片上物体真实框之间的位置关系对候选区域进行标注。跟真实框足够接近的那些候选区域会被标注为正样本，同时将真实框的位置作为正样本的位置目标。偏离真实框较大的那些候选区域则会被标注为负样本，负样本不需要预测位置或者类别。
- 使用卷积神经网络提取图片特征并对候选区域的位置和类别进行预测。这样每个预测框就可以看成是一个样本，根据真实框相对它的位置和类别进行了标注而获得标签值，通过网络模型预测其位置和类别，将网络预测值和标签值进行比较，就可以建立起损失函数。
YOLOv3算法训练过程的流程图如 图1 所示：
图1：YOLOv3算法训练流程图
- 图1 左边是输入图片，上半部分所示的过程是使用卷积神经网络对图片提取特征，随着网络不断向前传播，特征图的尺寸越来越小，每个像素点会代表更加抽象的特征模式，直到输出特征图，其尺寸减小为原图的
1
32
\frac{1}{32}
321。 - 图1 下半部分描述了生成候选区域的过程，首先将原图划分成多个小方块，每个小方块的大小是
32
×
32
32 \times 32
32×32，然后以每个小方块为中心分别生成一系列锚框，整张图片都会被锚框覆盖到。在每个锚框的基础上产生一个与之对应的预测框，根据锚框和预测框与图片上物体真实框之间的位置关系，对这些预测框进行标注。 - 将上方支路中输出的特征图与下方支路中产生的预测框标签建立关联，创建损失函数，开启端到端的训练过程。
接下来具体介绍流程中各节点的原理和代码实现。
一、产生候选区域
如何产生候选区域，是检测模型的核心设计方案。目前大多数基于卷积神经网络的模型所采用的方式大体如下：
- 按一定的规则在图片上生成一系列位置固定的锚框，将这些锚框看作是可能的候选区域。
- 对锚框是否包含目标物体进行预测，如果包含目标物体，还需要预测所包含物体的类别，以及预测框相对于锚框位置需要调整的幅度。
生成锚框
将原始图片划分成
m
×
n
m\times n
m×n个区域，如下图所示，原始图片高度
H
=
640
H=640
H=640, 宽度
W
=
480
W=480
W=480，如果我们选择小块区域的尺寸为
32
×
32
32 \times 32
32×32，则
m
m
m和
n
n
n分别为：
m
=
640
32
=
20
m = \frac{640}{32} = 20
m=32640=20
n
=
480
32
=
15
n = \frac{480}{32} = 15
n=32480=15
如 图2 所示，将原始图像分成了20行15列小方块区域。
图2：将图片划分成多个32x32的小方块
YOLOv3算法会在每个区域的中心，生成一系列锚框。为了展示方便，我们先在图中第十行第四列的小方块位置附近画出生成的锚框，如 图3 所示。
注意：
这里为了跟程序中的编号对应，最上面的行号是第0行，最左边的列号是第0列。
图3：在第10行第4列的小方块区域生成3个锚框
图11 展示在每个区域附近都生成3个锚框，很多锚框堆叠在一起可能不太容易看清楚，但过程跟上面类似，只是需要以每个区域的中心点为中心，分别生成3个锚框。
图4：在每个小方块区域生成3个锚框
生成预测框
在前面已经指出，锚框的位置都是固定好的，不可能刚好跟物体边界框重合，需要在锚框的基础上进行位置的微调以生成预测框。预测框相对于锚框会有不同的中心位置和大小，采用什么方式能得到预测框呢？我们先来考虑如何生成其中心位置坐标。
比如上面图中在第10行第4列的小方块区域中心生成的一个锚框，如绿色虚线框所示。以小方格的宽度为单位长度，
此小方块区域左上角的位置坐标是：
c
x
=
4
c_x = 4
cx=4
c
y
=
10
c_y = 10
cy=10
此锚框的区域中心坐标是：
c
e
n
t
e
r
_
x
=
c
x
+
0.5
=
4.5
center\_x = c_x + 0.5 = 4.5
center_x=cx+0.5=4.5
c
e
n
t
e
r
_
y
=
c
y
+
0.5
=
10.5
center\_y = c_y + 0.5 = 10.5
center_y=cy+0.5=10.5
可以通过下面的方式生成预测框的中心坐标：
b
x
=
c
x
+
σ
(
t
x
)
b_x = c_x + \sigma(t_x)
bx=cx+σ(tx)
b
y
=
c
y
+
σ
(
t
y
)
b_y = c_y + \sigma(t_y)
by=cy+σ(ty)
其中
t
x
t_x
tx和
t
y
t_y
ty为实数，
σ
(
x
)
\sigma(x)
σ(x)是我们之前学过的Sigmoid函数，其定义如下：
σ
(
x
)
=
1
1
+
e
x
p
(
−
x
)
\sigma(x) = \frac{1}{1 + exp(-x)}
σ(x)=1+exp(−x)1
由于Sigmoid的函数值在
0
∼
1
0 \thicksim 1
0∼1之间，因此由上面公式计算出来的预测框的中心点总是落在第十行第四列的小区域内部。
当
t
x
=
t
y
=
0
t_x=t_y=0
tx=ty=0时，
b
x
=
c
x
+
0.5
b_x = c_x + 0.5
bx=cx+0.5，
b
y
=
c
y
+
0.5
b_y = c_y + 0.5
by=cy+0.5，预测框中心与锚框中心重合，都是小区域的中心。
锚框的大小是预先设定好的，在模型中可以当作是超参数，下图中画出的锚框尺寸是
p
h
=
350
p_h = 350
ph=350
p
w
=
250
p_w = 250
pw=250
通过下面的公式生成预测框的大小：
b
h
=
p
h
e
t
h
b_h = p_h e^{t_h}
bh=pheth
b
w
=
p
w
e
t
w
b_w = p_w e^{t_w}
bw=pwetw
如果
t
x
=
t
y
=
0
,
t
h
=
t
w
=
0
t_x=t_y=0, t_h=t_w=0
tx=ty=0,th=tw=0，则预测框跟锚框重合。
如果给
t
x
,
t
y
,
t
h
,
t
w
t_x, t_y, t_h, t_w
tx,ty,th,tw随机赋值如下：
t
x
=
0.2
,
t
y
=
0.3
,
t
w
=
0.1
,
t
h
=
−
0.12
t_x = 0.2, t_y = 0.3, t_w = 0.1, t_h = -0.12
tx=0.2,ty=0.3,tw=0.1,th=−0.12
则可以得到预测框的坐标是(154.98, 357.44, 276.29, 310.42)，如 图5 中蓝色框所示。
说明：
这里坐标采用
x
y
w
h
xywh
xywh的格式。
图5：生成预测框
这里我们会问：当
t
x
,
t
y
,
t
w
,
t
h
t_x, t_y, t_w, t_h
tx,ty,tw,th取值为多少的时候，预测框能够跟真实框重合？为了回答问题，只需要将上面预测框坐标中的
b
x
,
b
y
,
b
h
,
b
w
b_x, b_y, b_h, b_w
bx,by,bh,bw设置为真实框的位置，即可求解出
t
t
t的数值。
令：
σ
(
t
x
∗
)
+
c
x
=
g
t
x
\sigma(t^*_x) + c_x = gt_x
σ(tx∗)+cx=gtx
σ
(
t
y
∗
)
+
c
y
=
g
t
y
\sigma(t^*_y) + c_y = gt_y
σ(ty∗)+cy=gty
p
w
e
t
w
∗
=
g
t
h
p_w e^{t^*_w} = gt_h
pwetw∗=gth
p
h
e
t
h
∗
=
g
t
w
p_h e^{t^*_h} = gt_w
pheth∗=gtw
可以求解出：
(
t
x
∗
,
t
y
∗
,
t
w
∗
,
t
h
∗
)
(t^*_x, t^*_y, t^*_w, t^*_h)
(tx∗,ty∗,tw∗,th∗)
如果
t
t
t是网络预测的输出值，将
t
∗
t^*
t∗作为目标值，以他们之间的差距作为损失函数，则可以建立起一个回归问题，通过学习网络参数，使得
t
t
t足够接近
t
∗
t^*
t∗，从而能够求解出预测框的位置坐标和大小。
预测框可以看作是在锚框基础上的一个微调，每个锚框会有一个跟它对应的预测框，我们需要确定上面计算式中的
t
x
,
t
y
,
t
w
,
t
h
t_x, t_y, t_w, t_h
tx,ty,tw,th，从而计算出与锚框对应的预测框的位置和形状。
二、 对候选区域进行标注
每个区域可以产生3种不同形状的锚框，每个锚框都是一个可能的候选区域，对这些候选区域我们需要了解如下几件事情：
-
锚框是否包含物体，这可以看成是一个二分类问题，使用标签objectness来表示。当锚框包含了物体时，objectness=1，表示预测框属于正类；当锚框不包含物体时，设置objectness=0，表示锚框属于负类。
-
如果锚框包含了物体，那么它对应的预测框的中心位置和大小应该是多少，或者说上面计算式中的
t
x
,
t
y
,
t
w
,
t
h
t_x, t_y, t_w, t_h
tx,ty,tw,th应该是多少，使用location标签。
-
如果锚框包含了物体，那么具体类别是什么，这里使用变量label来表示其所属类别的标签。
选取任意一个锚框对它进行标注，也就是需要确定其对应的objectness,
(
t
x
,
t
y
,
t
w
,
t
h
)
(t_x, t_y, t_w, t_h)
(tx,ty,tw,th)和label，下面将分别讲述如何确定这三个标签的值。
标注锚框是否包含物体
如 图6 所示，这里一共有3个目标，以最左边的人像为例，其真实框是
(
133.96
,
328.42
,
186.06
,
374.63
)
(133.96, 328.42, 186.06, 374.63)
(133.96,328.42,186.06,374.63)。
图6：选出与真实框中心位于同一区域的锚框
真实框的中心点坐标是：
c
e
n
t
e
r
_
x
=
133.96
center\_x = 133.96
center_x=133.96
c
e
n
t
e
r
_
y
=
328.42
center\_y = 328.42
center_y=328.42
i
=
133.96
/
32
=
4.18625
i = 133.96 / 32 = 4.18625
i=133.96/32=4.18625
j
=
328.42
/
32
=
10.263125
j = 328.42 / 32 = 10.263125
j=328.42/32=10.263125
它落在了第10行第4列的小方块内，如图6所示。此小方块区域可以生成3个不同形状的锚框，其在图上的编号和大小分别是
A
1
(
116
,
90
)
,
A
2
(
156
,
198
)
,
A
3
(
373
,
326
)
A_1(116, 90), A_2(156, 198), A_3(373, 326)
A1(116,90),A2(156,198),A3(373,326)。
用这3个不同形状的锚框跟真实框计算IoU，选出IoU最大的锚框。这里为了简化计算，只考虑锚框的形状，不考虑其跟真实框中心之间的偏移，具体计算结果如 图7 所示。
图7：选出与真实框与锚框的IoU
其中跟真实框IoU最大的是锚框
A
3
A_3
A3，形状是
(
373
,
326
)
(373, 326)
(373,326)，将它所对应的预测框的objectness标签设置为1，其所包括的物体类别就是真实框里面的物体所属类别。
依次可以找出其他几个真实框对应的IoU最大的锚框，然后将它们的预测框的objectness标签也都设置为1。这里一共有
20
×
15
×
3
=
900
20 \times 15 \times 3 = 900
20×15×3=900个锚框，只有3个预测框会被标注为正。
由于每个真实框只对应一个objectness标签为正的预测框，如果有些预测框跟真实框之间的IoU很大，但并不是最大的那个，那么直接将其objectness标签设置为0当作负样本，可能并不妥当。为了避免这种情况，YOLOv3算法设置了一个IoU阈值iou_threshold，当预测框的objectness不为1，但是其与某个真实框的IoU大于iou_threshold时，就将其objectness标签设置为-1，不参与损失函数的计算。
所有其他的预测框，其objectness标签均设置为0，表示负类。
对于objectness=1的预测框，需要进一步确定其位置和包含物体的具体分类标签，但是对于objectness=0或者-1的预测框，则不用管他们的位置和类别。
标注预测框的位置坐标标签
当锚框objectness=1时，需要确定预测框位置相对于它微调的幅度，也就是锚框的位置标签。
在前面我们已经问过这样一个问题：当
t
x
,
t
y
,
t
w
,
t
h
t_x, t_y, t_w, t_h
tx,ty,tw,th取值为多少的时候，预测框能够跟真实框重合？其做法是将预测框坐标中的
b
x
,
b
y
,
b
h
,
b
w
b_x, b_y, b_h, b_w
bx,by,bh,bw设置为真实框的坐标，即可求解出
t
t
t的数值。
令：
σ
(
t
x
∗
)
+
c
x
=
g
t
x
\sigma(t^*_x) + c_x = gt_x
σ(tx∗)+cx=gtx
σ
(
t
y
∗
)
+
c
y
=
g
t
y
\sigma(t^*_y) + c_y = gt_y
σ(ty∗)+cy=gty
p
w
e
t
w
∗
=
g
t
w
p_w e^{t^*_w} = gt_w
pwetw∗=gtw
p
h
e
t
h
∗
=
g
t
h
p_h e^{t^*_h} = gt_h
pheth∗=gth
对于
t
x
∗
t_x^*
tx∗和
t
y
∗
t_y^*
ty∗，由于Sigmoid的反函数不好计算，我们直接使用
σ
(
t
x
∗
)
\sigma(t^*_x)
σ(tx∗)和
σ
(
t
y
∗
)
\sigma(t^*_y)
σ(ty∗)作为回归的目标。
d
x
∗
=
σ
(
t
x
∗
)
=
g
t
x
−
c
x
d_x^* = \sigma(t^*_x) = gt_x - c_x
dx∗=σ(tx∗)=gtx−cx
d
y
∗
=
σ
(
t
y
∗
)
=
g
t
y
−
c
y
d_y^* = \sigma(t^*_y) = gt_y - c_y
dy∗=σ(ty∗)=gty−cy
t
w
∗
=
l
o
g
(
g
t
w
p
w
)
t^*_w = log(\frac{gt_w}{p_w})
tw∗=log(pwgtw)
t
h
∗
=
l
o
g
(
g
t
h
p
h
)
t^*_h = log(\frac{gt_h}{p_h})
th∗=log(phgth)
如果
(
t
x
,
t
y
,
t
h
,
t
w
)
(t_x, t_y, t_h, t_w)
(tx,ty,th,tw)是网络预测的输出值，将
(
d
x
∗
,
d
y
∗
,
t
w
∗
,
t
h
∗
)
(d_x^*, d_y^*, t_w^*, t_h^*)
(dx∗,dy∗,tw∗,th∗)作为
(
σ
(
t
x
)
,
σ
(
t
y
)
,
t
h
,
t
w
)
(\sigma(t_x), \sigma(t_y), t_h, t_w)
(σ(tx),σ(ty),th,tw)的目标值，以它们之间的差距作为损失函数，则可以建立起一个回归问题，通过学习网络参数，使得
t
t
t足够接近
t
∗
t^*
t∗，从而能够求解出预测框的位置。
标注锚框包含物体类别的标签
对于objectness=1的锚框，需要确定其具体类别。正如上面所说，objectness标注为1的锚框，会有一个真实框跟它对应，该锚框所属物体类别，即是其所对应的真实框包含的物体类别。这里使用one-hot向量来表示类别标签label。比如一共有10个分类，而真实框里面包含的物体类别是第2类，则label为
(
0
,
1
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
)
(0,1,0,0,0,0,0,0,0,0)
(0,1,0,0,0,0,0,0,0,0)
对上述步骤进行总结，标注的流程如 图8 所示。
图8：标注流程示意图
通过这种方式，我们在每个小方块区域都生成了一系列的锚框作为候选区域，并且根据图片上真实物体的位置，标注出了每个候选区域对应的objectness标签、位置需要调整的幅度以及包含的物体所属的类别。位置需要调整的幅度由4个变量描述
(
t
x
,
t
y
,
t
w
,
t
h
)
(t_x, t_y, t_w, t_h)
(tx,ty,tw,th)，objectness标签需要用一个变量描述
o
b
j
obj
obj，描述所属类别的变量长度等于类别数C。
对于每个锚框，模型需要预测输出
(
t
x
,
t
y
,
t
w
,
t
h
,
P
o
b
j
,
P
1
,
P
2
,
.
.
.
,
P
C
)
(t_x, t_y, t_w, t_h, P_{obj}, P_1, P_2,... , P_C)
(tx,ty,tw,th,Pobj,P1,P2,...,PC)，其中
P
o
b
j
P_{obj}
Pobj是锚框是否包含物体的概率，
P
1
,
P
2
,
.
.
.
,
P
C
P_1, P_2,... , P_C
P1,P2,...,PC则是锚框包含的物体属于每个类别的概率。接下来让我们一起学习如何通过卷积神经网络输出这样的预测值。
# 标注预测框的objectness
def get_objectness_label(img, gt_boxes, gt_labels, iou_threshold = 0.7,
anchors = [116, 90, 156, 198, 373, 326],
num_classes=7, downsample=32):
"""
img 是输入的图像数据，形状是[N, C, H, W]
gt_boxes，真实框，维度是[N, 50, 4]，其中50是真实框数目的上限，当图片中真实框不足50个时，不足部分的坐标全为0
真实框坐标格式是xywh，这里使用相对值
gt_labels，真实框所属类别，维度是[N, 50]
iou_threshold，当预测框与真实框的iou大于iou_threshold时不将其看作是负样本
anchors，锚框可选的尺寸
anchor_masks，通过与anchors一起确定本层级的特征图应该选用多大尺寸的锚框
num_classes，类别数目
downsample，特征图相对于输入网络的图片尺寸变化的比例
"""
img_shape = img.shape
batchsize = img_shape[0]
num_anchors = len(anchors) // 2
input_h = img_shape[2]
input_w = img_shape[3]
# 将输入图片划分成num_rows x num_cols个小方块区域，每个小方块的边长是 downsample
# 计算一共有多少行小方块
num_rows = input_h // downsample
# 计算一共有多少列小方块
num_cols = input_w // downsample
label_objectness = np.zeros([batchsize, num_anchors, num_rows, num_cols])
label_classification = np.zeros([batchsize, num_anchors, num_classes, num_rows, num_cols])
label_location = np.zeros([batchsize, num_anchors, 4, num_rows, num_cols])
scale_location = np.ones([batchsize, num_anchors, num_rows, num_cols])
# 对batchsize进行循环，依次处理每张图片
for n in range(batchsize):
# 对图片上的真实框进行循环，依次找出跟真实框形状最匹配的锚框
for n_gt in range(len(gt_boxes[n])):
gt = gt_boxes[n][n_gt]
gt_cls = gt_labels[n][n_gt]
gt_center_x = gt[0]
gt_center_y = gt[1]
gt_width = gt[2]
gt_height = gt[3]
if (gt_width < 1e-3) or (gt_height < 1e-3):
continue
i = int(gt_center_y * num_rows)
j = int(gt_center_x * num_cols)
ious = []
for ka in range(num_anchors):
bbox1 = [0., 0., float(gt_width), float(gt_height)]
anchor_w = anchors[ka * 2]
anchor_h = anchors[ka * 2 + 1]
bbox2 = [0., 0., anchor_w/float(input_w), anchor_h/float(input_h)]
# 计算iou
iou = box_iou_xywh(bbox1, bbox2)
ious.append(iou)
ious = np.array(ious)
inds = np.argsort(ious)
k = inds[-1]
label_objectness[n, k, i, j] = 1
c = gt_cls
label_classification[n, k, c, i, j] = 1.
# for those prediction bbox with objectness =1, set label of location
dx_label = gt_center_x * num_cols - j
dy_label = gt_center_y * num_rows - i
dw_label = np.log(gt_width * input_w / anchors[k*2])
dh_label = np.log(gt_height * input_h / anchors[k*2 + 1])
label_location[n, k, 0, i, j] = dx_label
label_location[n, k, 1, i, j] = dy_label
label_location[n, k, 2, i, j] = dw_label
label_location[n, k, 3, i, j] = dh_label
# scale_location用来调节不同尺寸的锚框对损失函数的贡献，作为加权系数和位置损失函数相乘
scale_location[n, k, i, j] = 2.0 - gt_width * gt_height
# 目前根据每张图片上所有出现过的gt box，都标注出了objectness为正的预测框，剩下的预测框则默认objectness为0
# 对于objectness为1的预测框，标出了他们所包含的物体类别，以及位置回归的目标
return label_objectness.astype('float32'), label_location.astype('float32'), label_classification.astype('float32'), \
scale_location.astype('float32')
# 计算IoU，矩形框的坐标形式为xywh
def box_iou_xywh(box1, box2):
x1min, y1min = box1[0] - box1[2]/2.0, box1[1] - box1[3]/2.0
x1max, y1max = box1[0] + box1[2]/2.0, box1[1] + box1[3]/2.0
s1 = box1[2] * box1[3]
x2min, y2min = box2[0] - box2[2]/2.0, box2[1] - box2[3]/2.0
x2max, y2max = box2[0] + box2[2]/2.0, box2[1] + box2[3]/2.0
s2 = box2[2] * box2[3]
xmin = np.maximum(x1min, x2min)
ymin = np.maximum(y1min, y2min)
xmax = np.minimum(x1max, x2max)
ymax = np.minimum(y1max, y2max)
inter_h = np.maximum(ymax - ymin, 0.)
inter_w = np.maximum(xmax - xmin, 0.)
intersection = inter_h * inter_w
union = s1 + s2 - intersection
iou = intersection / union
return iou
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
版权声明：本文为CSDN博主「天涯尽头黄鹤楼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/pidzhengding/article/details/122826786
暂无评论