“反正关注我之后，拿offer都拿到手软，工资都蹭蹭的涨”

更多都在微信公众号：hulugeAI

问题1：概述nms

当两个box空间位置非常接近，就以score更高的那个作为基准，看IOU即重合度如何，如果与其重合度超过阈值，就抑制score更小的box，因为没有必要输出两个接近的box，只保留score大的就可以了。

---

 

问题2：NMS的过程：

1 将各组box按照score降序排列

2 从score最大值开始，置为当前box，保存idex，然后依次遍历后面的box，计算与当前box的IOU值，若大于阈值，则抑制，不会输出

3 完成一轮遍历后，继续选择下一个非抑制的box作为当前box，重复步骤2

4 返回没有被抑制的index即符合条件的box

---

问题3:NMS的代码实现

def NMS(dects,threshhold):
    """
    detcs:二维数组(n_samples,5)
    5列：x1,y1,x2,y2,score
    threshhold: IOU阈值
    """
    x1=dects[:,0]
    y1=dects[:,1]
    x2=dects[:,2]
    y2=dects[:,3]
    score=dects[:,4]
    ndects=dects.shape[0]#box的数量
    area=(x2-x1+1)*(y2-y1+1)
    order=score.argsort()[::-1] #score从大到小排列的indexs,一维数组
    keep=[] #保存符合条件的index
    suppressed=np.array([0]*ndects) #初始化为0，若大于threshhold,变为1，表示被抑制
    
    for _i in range(ndects):
        i=order[_i]  #从得分最高的开始遍历
        if suppressed[i]==1:
            continue
        keep.append(i) 
        for _j in range(i+1,ndects):
            j=order[_j]
            if suppressed[j]==1: #若已经被抑制，跳过
                continue
            xx1=np.max(x1[i],x1[j])#求两个box的交集面积interface
            yy1=np.max(y1[i],y1j])
            xx2=np.min(x2[i],x2[j])
            yy2=np.min(y2[i],y2[j])
            w=np.max(0,xx2-xx1+1)
            h=np.max(0,yy2-yy1+1)
            interface=w*h
            overlap=interface/(area[i]+area[j]-interface) #计算IOU（交/并）
            
            if overlap>=threshhold:#IOU若大于阈值，则抑制
                suppressed[j]=1
    return keep

 

问题5:NMS的变形，softnms

非最大抑制（Non-maximum suppression, NMS）是物体检测流程中重要的组成部分（如下图划线部分）。NMS算法首先按照得分从高到低对建议框进行排序，然后分数最高的检测框M被选中，其他框与被选中建议框有明显重叠的框被抑制。该过程被不断递归的应用于其余检测框。根据算法的设计，如果一个物体处于预设的重叠阈值之内，可能会导致检测不到该待检测物体。即当两个目标框接近时，分数更低的框就会因为与之重叠面积过大而被删掉

Soft-NMS的优势

• 它仅需要对传统的NMS算法进行简单的改动且不增额外的参数。该Soft-NMS算法在标准数据集PASCAL VOC2007（较R-FCN和Faster-RCNN提升1.7%）和MS-COCO（较R-FCN提升1.3%，较Faster-RCNN提升1.1%）上均有提升。

• Soft-NMS具有与传统NMS相同的算法复杂度，使用高效。

• Soft-NMS不需要额外的训练，并易于实现，它可以轻松的被集成到任何物体检测流程中。

 

3.Soft-NMS原理

见下图伪代码，整个改进只需要使用绿色虚线表示的Soft-NMS替换红色虚线表示的NMS。

B集合是检测到的所有建议框，S集合是各个建议框得分（分数是指建议框包含物体的可能性大小），Nt是指手动设置的阈值。M为当前得分最高框，bi 为待处理框。

 

综上，soft-nms的核心就是降低置信度。比如一张人脸上有3个重叠的bounding box, 置信度分别为0.9, 0.7, 0.85 。选择得分最高的建议框，经过第一次处理过后，得分变成了0.9, 065, 0.55（此时将得分最高的保存在D中）。这时候再选择第二个bounding box作为得分最高的，处理后置信度分别为0.65, 0.45（这时候3个框也都还在），最后选择第三个，处理后得分不改变。最终经过soft-nms抑制后的三个框的置信度分别为0.9, 0.65, 0.45。最后设置阈值，将得分si小于阈值的去掉。

 

假如还检测出了3号框，而我们的最终目标是检测出1号和2号框，并且剔除3号框，原始的nms只会检测出一个1号框并剔除2号框和3号框，而softnms算法可以对1、2、3号检测狂进行置信度排序，可以知道这三个框的置信度从大到小的顺序依次为：1-》2-》3（由于是使用了惩罚，所有可以获得这种大小关系），如果我们再选择了合适的置信度阈值，就可以保留1号和2号，同时剔除3号，实现我们的功能。

但是，这里也有一个问题就是置信度的阈值如何选择，作者在这里依然使用手工设置的值，依然存在很大的局限性，所以该算法依然存在改进的空间。

def soft_nms(box, threshold=0.001, sigma=0.5, Nt=0.3, method=1):
    N = len(box)
    for i in range(N):
        maxscore = box[i, 4]
        maxpos = i

        tx1 = box[i, 0]
        ty1 = box[i, 1]
        tx2 = box[i, 2]
        ty2 = box[i, 3]
        ts = box[i, 4]

        pos = i + 1
        # get max box
        while pos < N:
            if maxscore < box[pos, 4]:
                maxscore = box[pos, 4]
                maxpos = pos
            pos = pos + 1

        # add max box as a detection
        box[i, 0] = box[maxpos, 0]
        box[i, 1] = box[maxpos, 1]
        box[i, 2] = box[maxpos, 2]
        box[i, 3] = box[maxpos, 3]
        box[i, 4] = box[maxpos, 4]

        # swap ith box with position of max box
        box[maxpos, 0] = tx1
        box[maxpos, 1] = ty1
        box[maxpos, 2] = tx2
        box[maxpos, 3] = ty2
        box[maxpos, 4] = ts

        tx1 = box[i, 0]
        ty1 = box[i, 1]
        tx2 = box[i, 2]
        ty2 = box[i, 3]
        ts = box[i, 4]

        pos = i + 1

        # NMS iterations, note that N changes if detection box fall below threshold
        while pos < N:
            x1 = box[pos, 0]
            y1 = box[pos, 1]
            x2 = box[pos, 2]
            y2 = box[pos, 3]
            s = box[pos, 4]

            area = (x2 * y2)#(x2 - x1 + 1) * (y2 - y1 + 1)
            iw = (min(tx1 + tx2, x1 + x2) - max(tx1, x1) + 1) #(min(tx2, x2) - max(tx1, x1) + 1)
            if iw > 0:
                ih = (min(ty1 + ty2, y1 + y2) - max(ty1, y1) + 1) #(min(ty2, y2) - max(ty1, y1) + 1)
                if ih > 0:
                    ua = float(tx2 * ty2 + area - iw * ih)#float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
                    ov = iw * ih / ua  # iou between max box and detection box

                    if method == 1:  # linear
                        if ov > Nt:
                            weight = 1 - ov
                        else:
                            weight = 1
                    elif method == 2:  # gaussian
                        weight = np.exp(-(ov * ov) / sigma)
                    else:  # original NMS
                        if ov > Nt:
                            weight = 0
                        else:
                            weight = 1

                    box[pos, 4] = weight * box[pos, 4]

                    # if box score falls below threshold, discard the box by swapping with last box
                    # update N
                    if box[pos, 4] < threshold:
                        box[pos, 0] = box[N - 1, 0]
                        box[pos, 1] = box[N - 1, 1]
                        box[pos, 2] = box[N - 1, 2]
                        box[pos, 3] = box[N - 1, 3]
                        box[pos, 4] = box[N - 1, 4]
                        N = N - 1
                        pos = pos - 1

            pos = pos + 1

    keep = [i for i in range(N)]
    return keep

 

更多面试题关注我