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}3 2 1 。
- 图1 下半部分描述了生成候选区域的过程，首先将原图划分成多个小方块，每个小方块的大小是32 × 32 32 \times 32 3 2 ×3 2，然后以每个小方块为中心分别生成一系列锚框，整张图片都会被锚框覆盖到。在每个锚框的基础上产生一个与之对应的预测框，根据锚框和预测框与图片上物体真实框之间的位置关系，对这些预测框进行标注。
- 将上方支路中输出的特征图与下方支路中产生的预测框标签建立关联，创建损失函数，开启端到端的训练过程。
接下来具体介绍流程中各节点的原理和代码实现。
一、产生候选区域
如何产生候选区域，是检测模型的核心设计方案。目前大多数基于卷积神经网络的模型所采用的方式大体如下：
- 按一定的规则在图片上生成一系列位置固定的锚框，将这些锚框看作是可能的候选区域。
- 对锚框是否包含目标物体进行预测，如果包含目标物体，还需要预测所包含物体的类别，以及预测框相对于锚框位置需要调整的幅度。
将原始图片划分成m × n m\times n m ×n个区域，如下图所示，原始图片高度H = 640 H=640 H =6 4 0, 宽度W = 480 W=480 W =4 8 0，如果我们选择小块区域的尺寸为32 × 32 32 \times 32 3 2 ×3 2，则m m m和n n n分别为：
m = 640 32 = 20 m = \frac{640}{32} = 20 m =3 2 6 4 0 =2 0
n = 480 32 = 15 n = \frac{480}{32} = 15 n =3 2 4 8 0 =1 5
如 图2 所示，将原始图像分成了20行15列小方块区域。
图2：将图片划分成多个32×32的小方块
YOLOv3算法会在每个区域的中心，生成一系列锚框。为了展示方便，我们先在图中第十行第四列的小方块位置附近画出生成的锚框，如 图3 所示。
注意：
这里为了跟程序中的编号对应，最上面的行号是第0行，最左边的列号是第0列。
图3：在第10行第4列的小方块区域生成3个锚框
图11 展示在每个区域附近都生成3个锚框，很多锚框堆叠在一起可能不太容易看清楚，但过程跟上面类似，只是需要以每个区域的中心点为中心，分别生成3个锚框。
图4：在每个小方块区域生成3个锚框
在前面已经指出，锚框的位置都是固定好的，不可能刚好跟物体边界框重合，需要在锚框的基础上进行位置的微调以生成预测框。预测框相对于锚框会有不同的中心位置和大小，采用什么方式能得到预测框呢？我们先来考虑如何生成其中心位置坐标。
比如上面图中在第10行第4列的小方块区域中心生成的一个锚框，如绿色虚线框所示。以小方格的宽度为单位长度，
此小方块区域左上角的位置坐标是：
c x = 4 c_x = 4 c x =4
c y = 10 c_y = 10 c y =1 0
此锚框的区域中心坐标是：
c e n t e r _ x = c x + 0.5 = 4.5 center_x = c_x + 0.5 = 4.5 c e n t e r _x =c x +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 c e n t e r _y =c y +0 .5 =1 0 .5
可以通过下面的方式生成预测框的中心坐标：
b x = c x + σ ( t x ) b_x = c_x + \sigma(t_x)b x =c x +σ(t x )
b y = c y + σ ( t y ) b_y = c_y + \sigma(t_y)b y =c y +σ(t y )
其中t x t_x t x 和t y t_y t y 为实数，σ ( x ) \sigma(x)σ(x )是我们之前学过的Sigmoid函数，其定义如下：
σ ( x ) = 1 1 + e x p ( − x ) \sigma(x) = \frac{1}{1 + exp(-x)}σ(x )=1 +e x p (−x )1
由于Sigmoid的函数值在0 ∼ 1 0 \thicksim 1 0 ∼1之间，因此由上面公式计算出来的预测框的中心点总是落在第十行第四列的小区域内部。
当t x = t y = 0 t_x=t_y=0 t x =t y =0时，b x = c x + 0.5 b_x = c_x + 0.5 b x =c x +0 .5，b y = c y + 0.5 b_y = c_y + 0.5 b y =c y +0 .5，预测框中心与锚框中心重合，都是小区域的中心。
锚框的大小是预先设定好的，在模型中可以当作是超参数，下图中画出的锚框尺寸是
p h = 350 p_h = 350 p h =3 5 0
p w = 250 p_w = 250 p w =2 5 0
通过下面的公式生成预测框的大小：
b h = p h e t h b_h = p_h e^{t_h}b h =p h e t h
b w = p w e t w b_w = p_w e^{t_w}b w =p w e t w
如果t x = t y = 0 , t h = t w = 0 t_x=t_y=0, t_h=t_w=0 t x =t y =0 ,t h =t w =0，则预测框跟锚框重合。
如果给t x , t y , t h , t w t_x, t_y, t_h, t_w t x ,t y ,t h ,t w 随机赋值如下：
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 t x =0 .2 ,t y =0 .3 ,t w =0 .1 ,t h =−0 .1 2
则可以得到预测框的坐标是(154.98, 357.44, 276.29, 310.42)，如 图5 中蓝色框所示。
说明：
这里坐标采用x y w h xywh x y w h的格式。
图5：生成预测框
这里我们会问：当t x , t y , t w , t h t_x, t_y, t_w, t_h t x ,t y ,t w ,t h 取值为多少的时候，预测框能够跟真实框重合？为了回答问题，只需要将上面预测框坐标中的b x , b y , b h , b w b_x, b_y, b_h, b_w b x ,b y ,b h ,b w 设置为真实框的位置，即可求解出t t t的数值。
令：
σ ( t x ∗ ) + c x = g t x \sigma(t^_x) + c_x = gt_x σ(t x ∗)+c x =g t x
σ ( t y ∗ ) + c y = g t y \sigma(t^_y) + c_y = gt_y σ(t y ∗)+c y =g t y
p w e t w ∗ = g t h p_w e^{t^_w} = gt_h p w e t w ∗=g t h
p h e t h ∗ = g t w p_h e^{t^_h} = gt_w p h e t h ∗=g t w
可以求解出：( t x ∗ , t y ∗ , t w ∗ , t h ∗ ) (t^_x, t^_y, t^_w, t^_h)(t x ∗,t y ∗,t w ∗,t h ∗)
如果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 t x ,t y ,t w ,t h ，从而计算出与锚框对应的预测框的位置和形状。
二、 对候选区域进行标注
每个区域可以产生3种不同形状的锚框，每个锚框都是一个可能的候选区域，对这些候选区域我们需要了解如下几件事情：
- 锚框是否包含物体，这可以看成是一个二分类问题，使用标签objectness来表示。当锚框包含了物体时，objectness=1，表示预测框属于正类；当锚框不包含物体时，设置objectness=0，表示锚框属于负类。
- 如果锚框包含了物体，那么它对应的预测框的中心位置和大小应该是多少，或者说上面计算式中的t x , t y , t w , t h t_x, t_y, t_w, t_h t x ,t y ,t w ,t h 应该是多少，使用location标签。
- 如果锚框包含了物体，那么具体类别是什么，这里使用变量label来表示其所属类别的标签。
选取任意一个锚框对它进行标注，也就是需要确定其对应的objectness, ( t x , t y , t w , t h ) (t_x, t_y, t_w, t_h)(t x ,t y ,t w ,t h )和label，下面将分别讲述如何确定这三个标签的值。
如 图6 所示，这里一共有3个目标，以最左边的人像为例，其真实框是( 133.96 , 328.42 , 186.06 , 374.63 ) (133.96, 328.42, 186.06, 374.63)(1 3 3 .9 6 ,3 2 8 .4 2 ,1 8 6 .0 6 ,3 7 4 .6 3 )。
图6：选出与真实框中心位于同一区域的锚框
真实框的中心点坐标是：
c e n t e r _ x = 133.96 center_x = 133.96 c e n t e r _x =1 3 3 .9 6
c e n t e r _ y = 328.42 center_y = 328.42 c e n t e r _y =3 2 8 .4 2
i = 133.96 / 32 = 4.18625 i = 133.96 / 32 = 4.18625 i =1 3 3 .9 6 /3 2 =4 .1 8 6 2 5
j = 328.42 / 32 = 10.263125 j = 328.42 / 32 = 10.263125 j =3 2 8 .4 2 /3 2 =1 0 .2 6 3 1 2 5
它落在了第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)A 1 (1 1 6 ,9 0 ),A 2 (1 5 6 ,1 9 8 ),A 3 (3 7 3 ,3 2 6 )。
图7：选出与真实框与锚框的IoU
其中跟真实框IoU最大的是锚框A 3 A_3 A 3 ，形状是( 373 , 326 ) (373, 326)(3 7 3 ,3 2 6 )，将它所对应的预测框的objectness标签设置为1，其所包括的物体类别就是真实框里面的物体所属类别。
依次可以找出其他几个真实框对应的IoU最大的锚框，然后将它们的预测框的objectness标签也都设置为1。这里一共有20 × 15 × 3 = 900 20 \times 15 \times 3 = 900 2 0 ×1 5 ×3 =9 0 0个锚框，只有3个预测框会被标注为正。
由于每个真实框只对应一个objectness标签为正的预测框，如果有些预测框跟真实框之间的IoU很大，但并不是最大的那个，那么直接将其objectness标签设置为0当作负样本，可能并不妥当。为了避免这种情况，YOLOv3算法设置了一个IoU阈值iou_threshold，当预测框的objectness不为1，但是其与某个真实框的IoU大于iou_threshold时，就将其objectness标签设置为-1，不参与损失函数的计算。
所有其他的预测框，其objectness标签均设置为0，表示负类。
当锚框objectness=1时，需要确定预测框位置相对于它微调的幅度，也就是锚框的位置标签。
在前面我们已经问过这样一个问题：当t x , t y , t w , t h t_x, t_y, t_w, t_h t x ,t y ,t w ,t h 取值为多少的时候，预测框能够跟真实框重合？其做法是将预测框坐标中的b x , b y , b h , b w b_x, b_y, b_h, b_w b x ,b y ,b h ,b w 设置为真实框的坐标，即可求解出t t t的数值。
令：
σ ( t x ∗ ) + c x = g t x \sigma(t^_x) + c_x = gt_x σ(t x ∗)+c x =g t x
σ ( t y ∗ ) + c y = g t y \sigma(t^_y) + c_y = gt_y σ(t y ∗)+c y =g t y
p w e t w ∗ = g t w p_w e^{t^_w} = gt_w p w e t w ∗=g t w
p h e t h ∗ = g t h p_h e^{t^_h} = gt_h p h e t h ∗=g t h
对于t x ∗ t_x^t x ∗和t y ∗ t_y^t y ∗，由于Sigmoid的反函数不好计算，我们直接使用σ ( t x ∗ ) \sigma(t^_x)σ(t x ∗)和σ ( t y ∗ ) \sigma(t^_y)σ(t y ∗)作为回归的目标。
d x ∗ = σ ( t x ∗ ) = g t x − c x d_x^ = \sigma(t^_x) = gt_x – c_x d x ∗=σ(t x ∗)=g t x −c x
d y ∗ = σ ( t y ∗ ) = g t y − c y d_y^ = \sigma(t^_y) = gt_y – c_y d y ∗=σ(t y ∗)=g t y −c y
t w ∗ = l o g ( g t w p w ) t^*_w = log(\frac{gt_w}{p_w})t w ∗=l o g (p w g t w )
t h ∗ = l o g ( g t h p h ) t^*_h = log(\frac{gt_h}{p_h})t h ∗=l o g (p h g t h )
如果( t x , t y , t h , t w ) (t_x, t_y, t_h, t_w)(t x ,t y ,t h ,t w )是网络预测的输出值，将( d x ∗ , d y ∗ , t w ∗ , t h ∗ ) (d_x^, d_y^, t_w^, t_h^)(d x ∗,d y ∗,t w ∗,t h ∗)作为( σ ( t x ) , σ ( t y ) , t h , t w ) (\sigma(t_x), \sigma(t_y), t_h, t_w)(σ(t x ),σ(t y ),t h ,t w )的目标值，以它们之间的差距作为损失函数，则可以建立起一个回归问题，通过学习网络参数，使得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)(t x ,t y ,t w ,t h )，objectness标签需要用一个变量描述o b j obj o b j，描述所属类别的变量长度等于类别数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)(t x ,t y ,t w ,t h ,P o b j ,P 1 ,P 2 ,…,P C )，其中P o b j P_{obj}P o b j 是锚框是否包含物体的概率，P 1 , P 2 , . . . , P C P_1, P_2,… , P_C P 1 ,P 2 ,…,P C 则是锚框包含的物体属于每个类别的概率。接下来让我们一起学习如何通过卷积神经网络输出这样的预测值。
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 = 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])
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 = 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.
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[n, k, i, j] = 2.0 - gt_width * gt_height
return label_objectness.astype('float32'), label_location.astype('float32'), label_classification.astype('float32'), \
scale_location.astype('float32')
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提供了大量能使我们快速便捷地处理数据的函数和方法。
Original: https://blog.csdn.net/pidzhengding/article/details/122826786
Author: 天涯尽头黄鹤楼
Title: YOLOv3学习——锚框和候选区域
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/629544/
转载文章受原作者版权保护。转载请注明原作者出处！