自学教程：ssd网络测试

    num_classes = len(labelmap) + 1  # +1 for background
    net = build_ssd('test', 300, num_classes)  # initialize SSD
    net.load_state_dict(torch.load(args.trained_model))
    net.eval()

        if phase == 'test':
            self.softmax = nn.Softmax(dim=-1)
            self.detect = Detect(num_classes=self.num_classes, top_k=200,
                                 conf_thresh=0.01, nms_thresh=0.45)

        if self.phase == 'train':
            output = (loc.view(loc.size(0), -1, 4),  # [batch_size,num_priors,4]
                      conf.view(conf.size(0), -1, self.num_classes),  # [batch_size,num_priors,21]
                      self.priors)  # [num_priors,4]
        else:  # Test
            output = self.detect(
                loc.view(loc.size(0), -1, 4),  # 位置预测
                self.softmax(conf.view((conf.size(0), -1, self.num_classes))),  # 置信度预测
                self.priors.cuda()  # 先验锚点框
            )

class Detect(Function):
    def __init__(self, num_classes, top_k, conf_thresh, nms_thresh):
        self.num_classes = num_classes
        self.top_k = top_k
        # Parameters used in nms.
        self.nms_thresh = nms_thresh  # 非极大值抑制阈值
        self.conf_thresh = conf_thresh  # 置信度阈值

    def forward(self, loc_data, conf_data, prior_data):
        '''
        :param loc_data: 模型预测的锚点框位置偏差信息,shape[batch,num_priors,4]
        :param conf_data: 模型预测的锚点框置信度,[batch,num_priors,num_classes]
        :param prior_data: 先验锚点框,[num_priors,4]
        :return:最终预测结果,shape[batch,num_classes,top_k,5],其中5表示[置信度,xmin,ymin,xmax,ymax],
            top_k中前面不为0的是预测结果,后面为0是为了填充
        '''
        num = loc_data.shape[0]  # batch size
        num_priors = prior_data.shape[0]  # 8732
        output = torch.zeros(num, self.num_classes, self.top_k, 5)  # 保存结果
        conf_preds = conf_data.view(num, num_priors, self.num_classes).transpose(2, 1)  # 置信度预测,transpose是为了后续操作方便

        for i in range(num):
            decoded_boxes = decode(loc_data[i], prior_data, voc['variance'])  # shape:[num_priors,4],对预测锚点框进行解码
            # 对每个类别,执行nms
            conf_scores = conf_preds[i].clone()  # shape:[num_classes,num_priors]
            for cl in range(1, self.num_classes):
                c_mask = conf_scores[cl].gt(self.conf_thresh)  # 和置信度阈值进行比较,大于为true,否则为false
                scores = conf_scores[cl][c_mask]  # 得到置信度大于阈值的那些锚点框置信度
                if scores.shape[0] == 0:
                    # 说明锚点框与这一类的GT框不匹配,简介说明,不存在这一类的目标
                    continue
                l_mask = c_mask.unsqueeze(1).expand_as(decoded_boxes)
                boxes = decoded_boxes[l_mask].view(-1, 4)  # 得到置信度大于阈值的那些锚点框
                ids = nms(boxes, scores, self.nms_thresh, self.top_k)  # 对置信度大于阈值的那些锚点框进行nms,得到最终预测结果的index
                output[i, cl, :len(ids)] = torch.cat((scores[ids].unsqueeze(1),
                                                      boxes[ids]), 1)  # [置信度,xmin,ymin,xmax,ymax]
        return output

def decode(loc, priors, variances):
    '''
    对编码的坐标进行解码,返回预测框的坐标
    :param loc: 网络预测的锚点框偏差信息,shape[num_priors,4]
    :param priors: 先验锚点框,[num_priors,4]
    :return: 预测框的坐标[num_priors,4],4代表[xmin,ymin,xmax,ymax]
    '''
    boxes = torch.cat((
        priors[:, :2] + loc[:, :2] * priors[:, 2:] * variances[0],
        priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1])), 1)  # [中心点x,中心点y,宽,高]
    boxes[:, :2] -= boxes[:, 2:] / 2  # xmin,ymin
    boxes[:, 2:] += boxes[:, :2]  # xmax,ymax
    return boxes

def nms(boxes, scores, overlap=0.5, top_k=200):
    '''
    进行nms操作
    :param boxes: 模型预测的锚点框的坐标
    :param scores: 模型预测的锚点框对应某一类的置信度
    :param overlap:nms阈值
    :param top_k:选取前top_k个预测框进行操作
    :return:预测框的index
    '''
    keep = torch.zeros(scores.shape[0])
    if boxes.numel() == 0:  # numel()返回tensor里面所有元素的个数
        return keep
    _, idx = scores.sort(0)  # 升序排序
    idx = idx[-top_k:]  # 取得最大的top_k个置信度对应的index

    keep = []  # 记录最大最终锚点框的index
    while idx.numel() > 0:
        i = idx[-1]  # 取出置信度最大的锚点框的index
        keep.append(i)
        idx = idx[:-1]
        if idx.numel() == 0:
            break
        IOU = jaccard(boxes[i].unsqueeze(0), boxes[idx])  # 计算这个锚点框与其余锚点框的iou
        mask = IOU.le(overlap).squeeze(0)
        idx = idx[mask]  # 排除大于阈值的锚点框
    return torch.tensor(keep)

    # 记载数据
    dataset = VOCDetection(args.voc_root, [('2007', 'test')], BaseTransform(300, (104, 117, 123)),
                           VOCAnnotationTransform())

    for i in range(num_images):
        img, gt, h, w = dataset.pull_item(i)
        img = img.unsqueeze(0)
        if torch.cuda.is_available():
            img = img.cuda()

        detections = net(img)  # 得到结果,shape[1,21,200,5]
        for j in range(1, detections.shape[1]):  # 循环计算每个类别
            dets = detections[0, j, :]  # shape[200,5],表示每个类别中最多200个锚点框,每个锚点框有5个值[conf,xmin,ymin,xmax,ymax]
            mask = dets[:, 0].gt(0.).expand(5, dets.shape[0]).t()  # 取出置信度大于0的情况.因为可能会出现实际有值的锚点框少于200个
            dets = torch.masked_select(dets, mask).view(-1, 5)  # 取出这些锚点框
            if dets.shape[0] == 0:
                # 说明该图片不存在该类别
                continue
            boxes = dets[:, 1:]  # 取出锚点框坐标
            # 计算出真实坐标
            boxes[:, 0] *= w
            boxes[:, 1] *= h
            boxes[:, 2] *= w
            boxes[:, 3] *= h

            scores = dets[:, 0].numpy()
            # np.newaxis增加一个新轴
            # 注意[xmin,ymin,xmax,ymax,conf]
            cls_dets = np.hstack((boxes.numpy(), scores[:, np.newaxis])).astype(np.float32, copy=False)

            all_boxes[j][i] = cls_dets

def evaluate_detections(all_boxes, dataset):
    write_voc_results_file(all_boxes, dataset)  # 将所有检测结果写成文本,保存下来
    do_python_eval(use_07=False)

def write_voc_results_file(all_boxes, dataset):
    # 将检测结果按照每类写成文本,方便后面读取结果
    for cls_ind, cls in enumerate(labelmap):
        print('Writing {:s} VOC results file'.format(cls))
        if not os.path.exists(args.save_det_result):
            os.mkdir(args.save_det_result)
        filename = os.path.join(args.save_det_result, 'det_%s.txt' % (cls))
        with open(filename, 'w') as f:
            for im_ind, index in enumerate(dataset.ids):  # dataset.ids:[path,图片名]
                dets = all_boxes[cls_ind + 1][im_ind]  # 测试的时候,图片是按这个顺序读取的
                if dets == []:
                    continue
                for k in range(dets.shape[0]):
                    f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'.
                            format(index[1], dets[k, -1],
                                   dets[k, 0] + 1, dets[k, 1] + 1,
                                   dets[k, 2] + 1, dets[k, 3] + 1))

def do_python_eval(use_07=True):
    aps = []  # 保存所有类别的AP
    for i, cls in enumerate(labelmap):
        filename = os.path.join(args.save_det_result, 'det_%s.txt' % (cls))  # 读取这一类别的检测结果,对应上刚刚保存的结果
        rec, prec, ap = voc_eval(filename,
                                 os.path.join(args.voc_root, 'VOC2007', 'ImageSets', 'Main', 'test.txt'),
                                 cls,
                                 args.cachedir,
                                 ovthresh=0.5,
                                 use_07_metric=use_07)
        aps += [ap]
        print('AP for {} = {:.4f}'.format(cls, ap))

def voc_eval(detpath,  # 某一类别下检测结果,每一行由文件名,置信度和检测坐标组成
             imagesetfile,  # 包含所有测试图片的文件
             classname,  # 需要检测的类别
             cachedir,  # 缓存GT框的pickle文件
             ovthresh=0.5,  # IOU阈值
             use_07_metric=True):
    '''
    假设检测结果在detpath.format(classname)下
    假设GT框坐标在annopath.format(imagename)
    假设imagesetfile每行仅包含一个文件名
    缓存所有GT框
    '''
    if not os.path.isdir(cachedir):
        os.mkdir(cachedir)
    cachefile = os.path.join(cachedir, 'annots.pkl')
    # 读取所有检测图片
    with open(imagesetfile, 'r') as f:
        lines = f.readlines()
    imagenames = [x.strip() for x in lines]  # 每张测试图片的名字

    # 下面代码是创建缓存文件,方便读取
    if not os.path.isfile(cachefile):
        # 不存在GT框缓存文件,则创建
        recs = {}  # key为图片名字,value为该图片下所有检测信息
        for i, imagename in enumerate(imagenames):
            recs[imagename] = parse_rec(
                os.path.join(args.voc_root, 'VOC2007', 'Annotations',
                             '%s.xml') % (imagename))  # 返回该图片下所有xml信息,包含所有目标
            if i % 100 == 0:
                print('Reading annotation for {:d}/{:d}'.format(
                    i + 1, len(imagenames)))
        # 保存下来,方便下次读取
        print('Saving cached annotations to {:s}'.format(cachefile))
        with open(cachefile, 'wb') as f:
            pickle.dump(recs, f)
    else:
        # 如果已经存在该文件,则加载回来即可
        with open(cachefile, 'rb') as f:
            recs = pickle.load(f)

    # 为这一类提取GT框
    class_recs = {}
    npos = 0  # 这一类别的gt框总数
    for imagename in imagenames:
        R = [obj for obj in recs[imagename] if obj['name'] == classname]  # 提取某张测试图片下该类别的信息
        bbox = np.array([x['bbox'] for x in R])  # GT框坐标
        difficult = np.array([x['difficult'] for x in R]).astype(np.bool)  # 元素为true或者false,true表示难例
        det = [False] * len(R)  # 长度为len(R)的list,用于表示该GT框是否已经匹配过,len(R)可以理解为该测试图片下,该类别的数量
        npos = npos + sum(~difficult)  # 只选取非难例,计算非难例的个数,可以理解为GT框的个数
        class_recs[imagename] = {'bbox': bbox,
                                 'difficult': difficult,
                                 'det': det}

    # 读取这一类的检测结果
    with open(detpath, 'r') as f:
        lines = f.readlines()

    if any(lines) == 1:  # 不为空
        splitlines = [x.strip().split(' ') for x in lines]
        image_ids = [x[0] for x in splitlines]  # 图片名称集合,包含重复的
        confidence = np.array([float(x[1]) for x in splitlines])  # 置信度集合
        BB = np.array([[float(z) for z in x[2:]] for x in splitlines])  # 检测框集合

        # 根据置信度,降序排列
        sorted_ind = np.argsort(-confidence)  # 降序排名
        sorted_scores = np.sort(-confidence)  # 降序排列
        BB = BB[sorted_ind, :]  # 检测框根据置信度进行降序排列
        image_ids = [image_ids[x] for x in sorted_ind]

        nd = len(image_ids)  # 检测的目标总数
        tp = np.zeros(nd)  # 记录tp
        fp = np.zeros(nd)  # 记录fp,与tp互斥

        for d in range(nd):  # 循环每个预测框
            R = class_recs[image_ids[d]]  # 该图片下的真实信息
            bb = BB[d, :].astype(float)  # 预测框的坐标
            ovmax = -np.inf  # 预测框与GT框的IOU
            BBGT = R['bbox'].astype(float)  # GT框的坐标

            if BBGT.size > 0:
                # 计算多个GT框与一个预测框的IOU,选择最大IOU
                # 下面是计算IOU的流程
                ixmin = np.maximum(BBGT[:, 0], bb[0])
                iymin = np.maximum(BBGT[:, 1], bb[1])
                ixmax = np.minimum(BBGT[:, 2], bb[2])
                iymax = np.minimum(BBGT[:, 3], bb[3])
                iw = np.maximum(ixmax - ixmin, 0.)
                ih = np.maximum(iymax - iymin, 0.)
                inters = iw * ih
                uni = ((bb[2] - bb[0]) * (bb[3] - bb[1]) +
                       (BBGT[:, 2] - BBGT[:, 0]) *
                       (BBGT[:, 3] - BBGT[:, 1]) - inters)
                overlaps = inters / uni
                ovmax = np.max(overlaps)  # 得到该预测框与GT框最大的IOU值
                jmax = np.argmax(overlaps)  # 得到该预测框对应最大IOU的GT框的index

            if ovmax > ovthresh:
                # 当IOU大于阈值,才有机会判断为正例
                # 判断为fp有两种情况:
                # 1.该GT框被置信度高的预测框匹配过
                # 2.IOU小于阈值
                if not R['difficult'][jmax]:
                    # 该GT框要求之前没有匹配过
                    # 由于置信度是降序排序的,GT框只匹配置信度最高的,其余认为是FP
                    tp[d] = 1.
                    R['det'][jmax] = 1
                else:
                    fp[d] = 1.
            else:
                fp[d] = 1

        # 计算recall,precision
        fp = np.cumsum(fp)  # shape:[1,nd]
        tp = np.cumsum(tp)  # shape:[1,nd]
        rec = tp / float(npos)  # 召回率
        prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)  # 准确率,防止除0
        ap = voc_ap(rec, prec, use_07_metric)
    else:
        rec = -1.
        prec = -1.
        ap = -1.

    return rec, prec, ap

def voc_ap(rec, prec, use_07_metric=True):
    '''
    根据召回率和准确率,计算AP
    AP计算有两种方式:1.11点计算;2.最大面积计算
    :param rec: [1,num_all_detect]
    :param prec: [1,num_all_detect]
    '''
    if use_07_metric:
        # 旧版,11点计算
        ap = 0.
        for t in np.arange(0., 1.1, 0.1):
            # 给召回率设定阈值,统计当召回率大于阈值的情况下,最大的准确率
            if np.sum(rec >= t) == 0:
                # 说明召回率没有比t更大
                p = 0
            else:
                p = np.max(prec[rec >= t])
            ap = ap + p / 11
    else:
        # 增加两个数字,是为了方便计算
        mrec = np.concatenate(([0.], rec, [1.]))  # shape:[1,num_all_detect+2]
        mpre = np.concatenate(([0.], prec, [0.]))

        # 计算最大面积
        for i in range(mpre.size - 1, 0, -1):
            # 取右边的最大值
            mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])

        # 得到与前面的数值不一样的index,可以理解成,计算面积时的边长
        i = np.where(mrec[1:] != mrec[:-1])[0]
        ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])  # 计算面积,长*宽
    return ap