在anchor_generator.py中，集成了很多中anchor的生成方式，趁阅读源码mmdetection之际，对其进行一下总结。
(先总结下faster rcnn， yolov3， SSD，后续继续补充）
一、anchor生成
生成anchor的总体思路是，首先生成base_anchor，然后网格化（meshgrid）生成其他anchor。
1、faster rcnn
faster rcnn的anchor生成是最经典的，其他anchor生成方式与之相比大同小异。在anchor_generator中，可以
看到它是在没有使用for循环的情况下，如何生成的anchor的。
首先是base_anchor。以（0，0）为左上角，以（stride, stride）为基本(w, h)，分别与scale，ratio计算得到的多个
anchor。比如scale = [8, 16, 32]（w，h的大小） , ratios=[0.5, 1.0, 2.0]（w和h的比例）, 那就是生成9个anchor。
1 def gen_single_level_base_anchors(self,
2 base_size,
3 scales,
4 ratios,
5 center=None):
6 """Generate base anchors of a single level.
7
8 Args:
9 base_size (int | float): Basic size of an anchor.
10 scales (torch.Tensor): Scales of the anchor.
11 ratios (torch.Tensor): The ratio between between the height
12 and width of anchors in a single level.
13 center (tuple[float], optional): The center of the base anchor
14 related to a single feature grid. Defaults to None.
15
16 Returns:
17 torch.Tensor: Anchors in a single-level feature maps.
18 """
19 w = base_size
20 h = base_size
21 if center is None:
22 x_center = self.center_offset * w
23 y_center = self.center_offset * h
24 else:
25 x_center, y_center = center
26
27 h_ratios = torch.sqrt(ratios)
28 w_ratios = 1 / h_ratios
29 if self.scale_major:
30 ws = (w * w_ratios[:, None] * scales[None, :]).view(-1)
31 hs = (h * h_ratios[:, None] * scales[None, :]).view(-1)
32 else:
33 ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
34 hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)
35
36 # use float anchor and the anchor's center is aligned with the
37 # pixel center
38 base_anchors = [
39 x_center - 0.5 * ws, y_center - 0.5 * hs, x_center + 0.5 * ws,
40 y_center + 0.5 * hs
41 ]
42 base_anchors = torch.stack(base_anchors, dim=-1)
43
44 return base_anchors
有了base_anchor，那就只需在其他位置上，对base_anchor进行相应的偏移即可。因此，先通过meshgrid，生成各个位置，然后加上base_anchor。
1 def _meshgrid(self, x, y, row_major=True):
2 """Generate mesh grid of x and y.
3
4 Args:
5 x (torch.Tensor): Grids of x dimension.
6 y (torch.Tensor): Grids of y dimension.
7 row_major (bool, optional): Whether to return y grids first.
8 Defaults to True.
9
10 Returns:
11 tuple[torch.Tensor]: The mesh grids of x and y.
12 """
13 xx = x.repeat(len(y))
14 yy = y.view(-1, 1).repeat(1, len(x)).view(-1)
15 if row_major:
16 return xx, yy
17 else:
18 return yy, xx
19
20 def single_level_grid_anchors(self,
21 base_anchors,
22 featmap_size,
23 stride=(16, 16),
24 device='cuda'):
25 """Generate grid anchors of a single level.
26
27 Note:
28 This function is usually called by method ``self.grid_anchors``.
29
30 Args:
31 base_anchors (torch.Tensor): The base anchors of a feature grid.
32 featmap_size (tuple[int]): Size of the feature maps.
33 stride (tuple[int], optional): Stride of the feature map in order
34 (w, h). Defaults to (16, 16).
35 device (str, optional): Device the tensor will be put on.
36 Defaults to 'cuda'.
37
38 Returns:
39 torch.Tensor: Anchors in the overall feature maps.
40 """
41 feat_h, feat_w = featmap_size
42 # convert Tensor to int, so that we can covert to ONNX correctlly
43 feat_h = int(feat_h)
44 feat_w = int(feat_w)
45 shift_x = torch.arange(0, feat_w, device=device) * stride[0]
46 shift_y = torch.arange(0, feat_h, device=device) * stride[1]
47
48 shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
49 shifts = torch.stack([shift_xx, shift_yy, shift_xx, shift_yy], dim=-1)
50 shifts = shifts.type_as(base_anchors)
51 # first feat_w elements correspond to the first row of shifts
52 # add A anchors (1, A, 4) to K shifts (K, 1, 4) to get
53 # shifted anchors (K, A, 4), reshape to (K*A, 4)
54
55 all_anchors = base_anchors[None, :, :] + shifts[:, None, :]
56 all_anchors = all_anchors.view(-1, 4)
57 # first A rows correspond to A anchors of (0, 0) in feature map,
58 # then (0, 1), (0, 2), ...
59 return all_anchors
2、yolov2&yolov3
和faster rcnn的不同就是base_anchor。yolo的base_anchor是通过对数据集聚类得到的。如下，可以看到这里不需要在去
计算scale和ratio，剩下的就是网格化生成其余anchor。
1 def gen_single_level_base_anchors(self, base_sizes_per_level, center=None):
2 """Generate base anchors of a single level.
3
4 Args:
5 base_sizes_per_level (list[tuple[int, int]]): Basic sizes of
6 anchors.
7 center (tuple[float], optional): The center of the base anchor
8 related to a single feature grid. Defaults to None.
9
10 Returns:
11 torch.Tensor: Anchors in a single-level feature maps.
12 """
13 x_center, y_center = center
14 base_anchors = []
15 for base_size in base_sizes_per_level:
16 w, h = base_size
17
18 # use float anchor and the anchor's center is aligned with the
19 # pixel center
20 base_anchor = torch.Tensor([
21 x_center - 0.5 * w, y_center - 0.5 * h, x_center + 0.5 * w,
22 y_center + 0.5 * h
23 ])
24 base_anchors.append(base_anchor)
25 base_anchors = torch.stack(base_anchors, dim=0)
26
27 return base_anchors
3、SSD
SSD也类似，不同的地方就是anchor的尺度不再是固定的，而是变化的（参考论文给的尺度公式）：随着特征图减小，尺度逐渐增大（感受野大，anchor也要大）。
剩下的就和faster rcnn一样了。参考https://zhuanlan.zhihu.com/p/33544892
1 # 计算出在原图上，anchor大小（单边为60， 111， 162， 213， 264）
2 min_sizes = []
3 max_sizes = []
4 for ratio in range(int(min_ratio), int(max_ratio) + 1, step):
5 min_sizes.append(int(self.input_size * ratio / 100))
6 max_sizes.append(int(self.input_size * (ratio + step) / 100))
7
8 # anchor再增加一个尺度30
9 if self.input_size == 300:
10 if basesize_ratio_range[0] == 0.15: # SSD300 COCO
11 min_sizes.insert(0, int(self.input_size * 7 / 100))
12 max_sizes.insert(0, int(self.input_size * 15 / 100))
13
14 # 计算其 scale ratio
15 anchor_ratios = []
16 anchor_scales = []
17 for k in range(len(self.strides)):
18 scales = [1., np.sqrt(max_sizes[k] / min_sizes[k])]
19 anchor_ratio = [1.]
20 for r in ratios[k]:
21 anchor_ratio += [1 / r, r] # 4 or 6 ratio
22 anchor_ratios.append(torch.Tensor(anchor_ratio))
23 anchor_scales.append(torch.Tensor(scales))
二、anchor assigner
生成了anchor之后，要对其打标签，看看哪些是正样本，哪些是负样本。
1、MaxIouAssigner
SSD和faseter rcnn采用的方式，计算anchor与GT的IOU。对每个anchor，如果其IOU>pos_thread，则为正样本，如果IOU<neg_thread，则为背景类；此外，
在代码中还有一段细节。在上述策略中，有些GT可能没有匹配到任何的anchor，因此添加了一个补救措施来扩充正样本：遍历每一个GT，
查看iou最大的anchor，如果最大iou>pos_min_iou，那就标记为正样本。注意：这个其实并不能保证每个GT一定有anchor（跟GT遍历顺序有关），
并且会引入一些不太好的正样本，因此效果并不一定好。这边博客举了一个不错的例子
目标检测(MMdetection)——Retina(Anchor、Focal Loss) - 知乎 (zhihu.com)
1 if self.match_low_quality:
2 # Low-quality matching will overwirte the assigned_gt_inds assigned
3 # in Step 3. Thus, the assigned gt might not be the best one for
4 # prediction.
5 # For example, if bbox A has 0.9 and 0.8 iou with GT bbox 1 & 2,
6 # bbox 1 will be assigned as the best target for bbox A in step 3.
7 # However, if GT bbox 2's gt_argmax_overlaps = A, bbox A's
8 # assigned_gt_inds will be overwritten to be bbox B.
9 # This might be the reason that it is not used in ROI Heads.
10 for i in range(num_gts):
11 if gt_max_overlaps[i] >= self.min_pos_iou:
12 if self.gt_max_assign_all:
13 max_iou_inds = overlaps[i, :] == gt_max_overlaps[i]
14 assigned_gt_inds[max_iou_inds] = i + 1
15 else:
16 assigned_gt_inds[gt_argmax_overlaps[i]] = i + 1
2、GridAssigner
YOLO采用的方式，同样先计算anchor与GT的IOU。负样本标记方式相同，不同的是正样本。对于每个anchor，其最近网格的IOU>pos_thread并且其中心落入
该网格，则该anchor为正样本；对于每个GT，将其最近的anchor，赋值给该GT最近的格子。这就意味着，每个GT，其实只有一个正样本。
三、box编码
在训练过程中，并非直接使用GT和anchor的坐标直接训练，为了加速收敛，会对其进行编码，编码的方式略有不同。
这部分参考史上最详细的Yolov3边框预测分析_逍遥王的博客-CSDN博客