补充内容--目标检测之边界框解码【附代码】

            self.softmax = nn.Softmax(dim=-1)  # 所有类的概率相加为1
            # Detect(num_classes,bkg_label,top_k,conf_thresh,nms_thresh)
            # top_k:一张图片中，每一类的预测框的数量
            # conf_thresh 置信度阈值
            # nms_thresh：值越小表示要求的预测框重叠度越小，0.0表示不允许重叠
            self.detect = Detect(num_classes, 0, 200, confidence, nms_iou)

output = self.detect(
                loc.view(loc.size(0), -1, 4),
                self.softmax(conf.view(conf.size(0), -1, self.num_classes)),
                self.priors

    def forward(self, x):
        loc = list()
        conf = list()
        featrue = list()
        for k in range(len(self.backbone)):
            x = self.backbone[k](x)
        featrue.append(x)  # 最后一个特征层为batch_size,1024,19,19
        for (x, l, c) in zip(featrue, self.loc, self.conf):
            loc.append(l(x).permute(0, 2, 3, 1).contiguous())
            conf.append(c(x).permute(0, 2, 3, 1).contiguous())
        loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)
        conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)
        if self.phase == "test":
            output = self.detect(
                loc.view(loc.size(0), -1, 4),
                self.softmax(conf.view(conf.size(0), -1, self.num_classes)),
                self.priors
            )

class Detect(nn.Module):
    def __init__(self, num_classes, bkg_label, top_k, conf_thresh, nms_thresh):
        super().__init__()
        self.num_classes = num_classes  # 类别数量
        self.background_label = bkg_label  # 背景类标签
        self.top_k = top_k  # 预测结果取前k个结果
        self.nms_thresh = nms_thresh  # NMS阈值
        if nms_thresh <= 0:
            raise ValueError('nms_threshold must be non negative.')
        self.conf_thresh = conf_thresh  # 置信度
        self.variance = Config['variance']  # [0.1, 0.2]

    def forward(self, loc_data, conf_data, prior_data):
        # loc_data shape=(1,1444,4), conf_data shape=(1,1444,2), prior_data shape=(1444,4)
        # prior_data 和loc_data不一样，虽然都是表示边界，但loc是预测，prior_data是默认先验框。后面预测框和默认框要匹配
        loc_data = loc_data.cpu()  # shape is (batch_size,1444,4)后面的两维是先验框数量和边界框坐标
        conf_data = conf_data.cpu()  # shape is (batch_size,1444,num_classes[包含背景类])
        num = loc_data.size(0)  # shape is batch_size=1
        num_priors = prior_data.size(0)  # 先验框数量,1444
        output = torch.zeros(num, self.num_classes, self.top_k,
                             5)  # 建立一个output阵列存放输出 shape[batch_size,num_classes,200,5] 5是包含了类[预测的是什么类]和边界框信息
        # --------------------------------------#
        #   对分类预测结果进行reshape
        #   num, num_classes, num_priors
        #   conf_preds shape = [batch_size,num_classes,1444]
        # --------------------------------------#
        conf_preds = conf_data.view(num, num_priors, self.num_classes).transpose(2,
                                                                                 1)  # transpose是将num_priors,num_classes维度进行反转
        # 对每一张图片进行处理正常预测的时候只有一张图片，所以只会循环一次
        for i in range(num):
            # --------------------------------------#
            #   对先验框解码获得预测框
            #   解码后，获得的结果的shape为
            #   num_priors, 4
            # --------------------------------------#
            # decode传入参数:loc_data[0]【得到的预测边界回归的整个矩阵信息】,(1444,4)[所有先验框的坐标信息]，[0.1,0.2]
            decoded_boxes = decode(loc_data[i], prior_data, self.variance)  # 回归预测loc_data的结果对先验框进行调整
            conf_scores = conf_preds[i].clone()
            # --------------------------------------#
            #   获得每一个类对应的分类结果
            #   num_priors,
            # --------------------------------------#
            for cl in range(1, self.num_classes):
                # --------------------------------------#
                #   首先利用门限进行判断
                #   然后取出满足门限的得分
                # --------------------------------------#
                c_mask = conf_scores[cl].gt(self.conf_thresh)
                scores = conf_scores[cl][c_mask]
                if scores.size(0) == 0:
                    continue
                l_mask = c_mask.unsqueeze(1).expand_as(decoded_boxes)
                # --------------------------------------#
                #   将满足门限的预测框取出来
                # --------------------------------------#
                boxes = decoded_boxes[l_mask].view(-1, 4)
                # --------------------------------------#
                #   利用这些预测框进行非极大抑制
                # --------------------------------------#
                ids, count = nms(boxes, scores, self.nms_thresh, self.top_k)
                output[i, cl, :count] = torch.cat((scores[ids[:count]].unsqueeze(1), boxes[ids[:count]]), 1)
        return output

def decode(loc, priors, variances):
    # loc的shape = [1444,4]，预测值
    # priors的shape = (1444,4)，默认先验框
    # variances = [0.1, 0.2]
    # priors[:, :2]取前两列 为什么要乘variances，因为在encode中除了一个variances。除以variance是对预测box和真实box的误差进行放大，从而增加loss，增加梯度，加快收敛速度
    boxes = torch.cat((
        priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:],  # 调整先验框中心的位置 loc[:,:2]回归预测结果前两位的结果，priors[:, 2:]先验框的长和宽
        priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1])), 1)   # 调整后先验框的宽和高
    boxes[:, :2] -= boxes[:, 2:] / 2  # 先验框的左上角
    boxes[:, 2:] += boxes[:, :2]   # 先验的右下角
    return boxes

c_mask = conf_scores[cl].gt(self.conf_thresh)

l_mask = c_mask.unsqueeze(1).expand_as(decoded_boxes)

boxes = decoded_boxes[l_mask].view(-1, 4)

ids, count = nms(boxes, scores, self.nms_thresh, self.top_k)
                output[i, cl, :count] = torch.cat((scores[ids[:count]].unsqueeze(1), boxes[ids[:count]]), 1)