深度学习之非极大值抑制（Non-maximum suppression，NMS）

非极大值抑制（Non-maximum suppression，NMS）是一种去除非极大值的算法，常用于计算机视觉中的边缘检测、物体识别等。

算法流程

给出一张图片和上面许多物体检测的候选框（即每个框可能都代表某种物体），但是这些框很可能有互相重叠的部分，我们要做的就是只保留最优的框。假设有N个框，每个框被分类器计算得到的分数为$S_i,(1<=i<=N)$。

0. 建造一个存放待处理候选框的集合H，初始化为包含全部N个框;建造一个存放最优框的集合M，初始化为空集。

1. 将所有集合 H 中的框进行排序，选出分数最高的框 m，从集合 H 移到集合 M；

2. 遍历集合 H 中的框，分别与框 m 计算交并比（Interection-over-union，IoU），如果高于某个阈值（一般为0~0.5），则认为此框与 m 重叠，将此框从集合 H 中去除。

3. 回到第1步进行迭代，直到集合 H 为空。集合 M 中的框为我们所需。

需要优化的参数

IoU 的阈值是一个可优化的参数，一般范围为0~0.5，可以使用交叉验证来选择最优的参数。

示例

比如人脸识别的一个例子：

已经识别出了 5 个候选框，但是我们只需要最后保留两个人脸。

首先选出分数最大的框（0.98），然后遍历剩余框，计算 IoU，会发现露丝脸上的两个绿框都和 0.98 的框重叠率很大，都要去除。

然后只剩下杰克脸上两个框，选出最大框（0.81），然后遍历剩余框（只剩下0.67这一个了），发现0.67这个框与 0.81 的 IoU 也很大，去除。

至此所有框处理完毕。
​​
再比如定位一个车辆，最后算法就找出了一堆的方框，我们需要判别哪些矩形框是没用的。非极大值抑制：先假设有6个矩形框，根据分类器类别分类概率做排序，从小到大分别属于车辆的概率分别为A、B、C、D、E、F。

(1)从最大概率矩形框F开始，分别判断A~E与F的重叠度IOU是否大于某个设定的阈值;

(2)假设B、D与F的重叠度超过阈值，那么就扔掉B、D；并标记第一个矩形框F，是我们保留下来的。

(3)从剩下的矩形框A、C、E中，选择概率最大的E，然后判断E与A、C的重叠度，重叠度大于一定的阈值，那么就扔掉；并标记E是我们保留下来的第二个矩形框。

就这样一直重复，找到所有被保留下来的矩形框A、E。

代码

import numpy as np
 
def py_cpu_nms(dets, thresh):
    
    # 单独获取各个参数，以下参数shape = (5,)
    x1 = dets[:,0]
    y1 = dets[:,1]
    x2 = dets[:,2]
    y2 = dets[:,3]
    scores = dets[:,4]
    areas = (y2-y1+1) * (x2-x1+1)
    print("areas.shape: {}".format(areas.shape))
    print("areas: {}".format(areas))
 
    keep = []
 
    # 得分按照由高到低排序的索引, index.shape = (6,)
    index = scores.argsort()[::-1]
    print("index.shape: {}".format(index.shape))
    print("index: {}".format(index))
 
    while index.size >0:
        # i为得分最高的索引
        i = index[0]      
 
        # 将得分最高的索引追加到列表中
        keep.append(i)
 
        # 计算两个box左上角点坐标的最大值x11、y11和右下角坐标的最小值x22、y22
        # x11、y11、x22、y22 shape = (5,)
        x11 = np.maximum(x1[i], x1[index[1:]])
        y11 = np.maximum(y1[i], y1[index[1:]])
        x22 = np.minimum(x2[i], x2[index[1:]])
        y22 = np.minimum(y2[i], y2[index[1:]])
        print("index[1:]: {}".format(index[1:]))
        print("x1[index[1:]]: {}".format(x1[index[1:]]))
        print("x11: {}".format(x11))
        print("x11.shape: {}".format(x11.shape))
 
        # 当两个方框相交时，22-11最后得到w,h是正值
        # 当两个方框不相交的时候，22-11最后得到w,h是负值，则设置为0
        # w、h shape = (5,)
        w = np.maximum(0, x22-x11+1)
        h = np.maximum(0, y22-y11+1)
        print("w: {}".format(w))
        print("w.shape: {}".format(w.shape))
 
        # 计算交集面积
        # overlaps.shape = (5,)
        overlaps = w * h
        print("overlaps: {}".format(overlaps))
        print("overlaps.shape: {}".format(overlaps.shape))
 
        # 计算交并比
        # ious.shape = (5,)
        ious = overlaps / (areas[i] + areas[index[1:]] - overlaps)
        print("ious.shape: {}".format(ious.shape))
        print("ious: {}".format(ious))
 
        # 得到满足阈值条件的ious中的索引(ious相比index缺少第一个最大值)
        ious_idx = np.where(ious<=thresh)[0]
        print("ious<=thres idx: {}".format(ious_idx))
        # ious_idx+1得到在index中的索引
        index = index[ious_idx + 1]   # because index start from 1
        print("index: {}".format(index))
 
    return keep
 
if __name__ == "__main__":
 
    boxes=np.array([[100,100,210,210,0.72], # 0
                    [250,250,420,420,0.8],  # 1
                    [220,220,320,330,0.92], # 2
                    [100,100,210,210,0.72], # 3
                    [230,240,325,330,0.81], # 4
                    [220,230,315,340,0.9]]) # 5
 
    keep = py_cpu_nms(boxes, thresh=0.7)
    print("keep: {}".format(keep))