如果有了解过yolo网络，那肯定也听说过anchors，当然anchors这个概念布置在YOLO里面才有，在其他的目标检测中也存在anchors这个概念。对于anchors计算的一些公式这篇文章就不进行讲解了，这篇文章主要是讲在训练网络模型过程中anchors执行的流程，并将这个抽象的概念具体化，便于更深的理解yolo。
-
1. anchors是什么？
答：anchors其实就是在训练之前人为设定的先验框，网络输出结果的框就是在anchors的基础上进行调整的。所以说先验框设定的好坏对于模型的输出效果影响还是挺大的。在yolo中一般设定一个物体的先验框的个数一般是9个，例如：
anchors = np.array(
[[27., 183.], [87., 31.], [51., 62.], [139., 95.], [53., 50.], [60., 54.5], [87., 55.], [161., 41.], [49.5, 44.]])这个先验框anchors一共有9个元素，每一个元素代表一个先验框的宽高。例如【27,183】就表示第一个先验框的宽为27，高为183。
-
2.一张图片有多少个先验框？
答：先验框的个数与图片是哪个的物体的个数有关系，一个物体默认会设定9个先验框。
在标注的时候会用一个矩形框来将物体标注出来，这样子我们可以根据标注信息来获取物体的左上角（x1, y1）和右下角(x2,y2)坐标，然后计算出物体的中心坐标[(x2-x1)/2, (y2-y1)/2]。 这样子就可以把ancors表示出来了。下面就是原图与画了先验框的图片的对比：
3.先验框在哪一步会进行调整？
答：在YOLO网络里面，一张图片进入模型编码之后会输出三个feature map(特征层），分别用
小特征层(20,20)、中特征层(40,40)和大特征层(80,80)来表示。其中小特征层用于检测大物体，中特征层用于检测中等物体，大特征层用于检测小物体。（因为小特征层的尺寸比较小，也就是压缩的倍数多，小物体经过多次压缩的话在小特征层上面可能就不明显甚至没有，所以小特征用于检测大的物体）。anchors是在特征层上进行调整的，但最开始的anchors是相对于原图的，我们需要将anchors的大小以及物体的中心也对应到feature map上。我们可以从feature map上获取到物体中心以及框的宽高的偏移量offset_x, offset_y, offset_w, offset_h, 然后根据偏移量对先验框进行调整。
下面是先验框的可视化展示：
原图上：
特征层上：一共9个anchors，有3层特征层， 所以每层3个先验框
左边的红框是先验框没调整之前在特征层上的位置，黑点表示中心位置
右边的绿框是中心点和先验框调整之后在特征层上的位置
opt:懒得打字但又想记录一下的部分。
在训练过程中，对anchors的调整是在求loss前会对anchors进行调整，然后用调整后的anchors和真实框来计算loss_iou。
yolo过了模型之后有三个feature map，所以每个feature map上一个物体有三个anchor，在对anchors进行调整的时候会吧feature map的值调整到0~1之间，这是因为在feature map上每个网格的长度默认为1.
Last:代码实现部分：
代码引用到的YoloDataset, yolo_dataset_collate这两个函数在：
YoloDataset, yolo_dataset_collate：
YoloBody是网络结构，可以用YOLO系列的网络
import os
import random
import cv2
import torch
import numpy as np
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
from algorithm_code.yolov6.yolo_net import YoloBody
from algorithm_code.yolov6.yolo_dataloader import YoloDataset, yolo_dataset_collate
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
def sigmoid(x):
s = 1 / (1 + np.exp(-x))
return s
def get_anchors_and_decode(feats, anchors, center, num_classes, j):
feat1 = feats.new(feats.shape)
feats = feat1.cpu().numpy()
x, y = center
plt_w, plt_h = feats.shape[1:3]
# feats [batch_size, h, w, 3 * (5 + num_classes)]
num_anchors = len(anchors)
grid_shape = np.shape(feats)[1:3]
# 获得各个特征点的坐标信息。生成的shape为(h, w, num_anchors, 2)
grid_x = np.tile(np.reshape(np.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]), [grid_shape[0], 1, num_anchors, 1])
grid_y = np.tile(np.reshape(np.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]), [1, grid_shape[1], num_anchors, 1])
grid = np.concatenate([grid_x, grid_y], -1)
# 将先验框进行拓展，生成的shape为(h, w, num_anchors, 2)
anchors_tensor = np.reshape(anchors, [1, 1, num_anchors, 2])
anchors_tensor = np.tile(anchors_tensor, [grid_shape[0], grid_shape[1], 1, 1])
# 将预测结果调整成(batch_size,h,w,3,nc+5)
feats = np.reshape(feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
box_xy = sigmoid(feats[..., :2]) + grid
box_wh = np.exp(feats[..., 2:4]) * anchors_tensor
fig = plt.figure(figsize=(10., 10.,))
ax = fig.add_subplot(121)
plt.ylim(-2, plt_h)
plt.xlim(-2, plt_w)
plt.scatter(grid_x, grid_y)
plt.scatter(x, y, c='black')
plt.gca().invert_yaxis()
anchor_left = grid_x - anchors_tensor / 2
anchor_top = grid_y - anchors_tensor / 2
print(np.shape(anchor_left))
rect1 = plt.Rectangle([anchor_left[y, x, 0, 0], anchor_top[y, x, 0, 1]], anchors_tensor[0, 0, 0, 0],
anchors_tensor[0, 0, 0, 1], color="r", fill=False)
rect2 = plt.Rectangle([anchor_left[y, x, 1, 0], anchor_top[y, x, 1, 1]], anchors_tensor[0, 0, 1, 0],
anchors_tensor[0, 0, 1, 1], color="r", fill=False)
rect3 = plt.Rectangle([anchor_left[y, x, 2, 0], anchor_top[y, x, 2, 1]], anchors_tensor[0, 0, 2, 0],
anchors_tensor[0, 0, 2, 1], color="r", fill=False)
ax.add_patch(rect1)
ax.add_patch(rect2)
ax.add_patch(rect3)
ax = fig.add_subplot(122)
plt.ylim(-2, plt_h)
plt.xlim(-2, plt_w)
plt.scatter(grid_x, grid_y)
plt.scatter(x, y, c='black')
plt.scatter(box_xy[0, y, x, :, 0], box_xy[0, y, x, :, 1], c='r')
plt.gca().invert_yaxis()
pre_left = box_xy[..., 0] - box_wh[..., 0] / 2
pre_top = box_xy[..., 1] - box_wh[..., 1] / 2
rect1 = plt.Rectangle([pre_left[0, y, x, 0], pre_top[0, y, x, 0]], box_wh[0, y, x, 0, 0], box_wh[0, y, x, 0, 1],
color="g", fill=False)
rect2 = plt.Rectangle([pre_left[0, y, x, 1], pre_top[0, y, x, 1]], box_wh[0, y, x, 1, 0], box_wh[0, y, x, 1, 1],
color="g", fill=False)
rect3 = plt.Rectangle([pre_left[0, y, x, 2], pre_top[0, y, x, 2]], box_wh[0, y, x, 2, 0], box_wh[0, y, x, 2, 1],
color="g", fill=False)
ax.add_patch(rect1)
ax.add_patch(rect2)
ax.add_patch(rect3)
plt.savefig(r"C:\Users\HJ\Desktop\demo\%s_%s.jpg" % (i, j))
plt.close()
anchors = np.array(
[[27., 183.], [87., 31.], [51., 62.], [139., 95.], [53., 50.], [60., 54.5], [87., 55.], [161., 41.], [49.5, 44.]])
anchors_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
data_line = ['E:/私人文件/V3软件标注/定位/tags/1/1/1_00000001.jpg 42,74,113,289,0 228,236,306,308,1']
train_dataset = YoloDataset(data_line, [512, 512], 10, anchors, False, False)
gen_train = DataLoader(train_dataset, shuffle=True, batch_size=1, num_workers=0, pin_memory=True, drop_last=False,
collate_fn=yolo_dataset_collate)
model = YoloBody(num_classes=10).to("cuda")
for iteration, batch in enumerate(gen_train):
images, targets, y_trues = batch[0], batch[1], batch[2]
print("image shape:", images.shape)
boxes = targets[0].cpu().numpy()
boxes_center = [((box[0] + box[2]) / 2, (box[1] + box[3]) / 2) for box in boxes]
print("boxes:", boxes_center)
img_h, img_w = images.shape[2:4]
print("img_wh:", img_w, img_h)
with torch.no_grad():
images = images.to("cuda")
targets = [ann.to("cuda") for ann in targets]
y_trues = [ann.to("cuda") for ann in y_trues]
outputs = model(images)
for i, feat in enumerate(outputs):
input_anchor = anchors[anchors_mask[i]]
# print("input anchor:", input_anchor)
feat = feat.permute(0, 2, 3, 1)
print("feat.shape:", feat.shape)
# 1.获取feat 的高和宽
feat_h, feat_w = feat.shape[1:3]
# 2.有了原图大小和feat大小，就可以求出步长
stride_h, stride_w = img_h / feat_h, img_w / feat_w
print("stride:", stride_h, stride_w)
# 3.anchors是相对于原图的，而我们读取数据的到的image是经过resize之后得到的图片,所以我们要先把anchors对应到resize之后的图片，然后再映射到feature map
# 由于我这里原图是512,512. resize的大小也是512,512所以就不需要将anchor从原图映射到resize之后的图片，也就是少做了一个除法
feat_anchors = input_anchor / np.array([stride_w, stride_h]) # 把anchors从热size之后的图映射到feature map上
# 4.根据原图的坐标信息我们可以求出物体的中心位置，有了步长之后局可以求出物体在feature map上面的位置
for j, center in enumerate(boxes_center):
feat_x, feat_y = int(center[0] / stride_w), int(center[1] / stride_h)
print("第%s特征的x, y:" % i, feat_x, feat_y)
# 5.现在feature map,中心，anchors都有了，就可以画出anchors的图片了
get_anchors_and_decode(feat, feat_anchors, (feat_x, feat_y), 10, j)
print("==============================")