精华内容
下载资源
问答
  • 非极大值抑制算法

    千次阅读 2016-09-24 22:01:07
     非极大值抑制算法(Non-maximum suppression, NMS)的本质是搜索局部极大值,抑制极大值元素。 2. 3邻域情况下NMS的实现  3邻域情况下的NMS即判断一维数组I[W]的元素I[i](2    a. 算法流程3-5...

    1. 算法原理

      非极大值抑制算法(Non-maximum suppression, NMS)的本质是搜索局部极大值,抑制非极大值元素。

    2. 3邻域情况下NMS的实现

      3邻域情况下的NMS即判断一维数组I[W]的元素I[i](2<=i<=W-1)是否大于其左邻元素I[i-1]和右邻元素I[i+1],算法流程如下图所示:

      

      a. 算法流程3-5行判断当前元素是否大于其左邻与右邻元素,如符合条件,该元素即为极大值点。对于极大值点I[i],已知I[i]>I[i+1],故无需对i+1位置元素做进一步处理,直接跳至i+2位置,对应算法流程第12行。

        

      b. 若元素I[i]不满足算法流程第3行判断条件,将其右邻I[i+1]作为极大值候选,对应算法流程第7行。采用单调递增的方式向右查找,直至找到满足I[i]>I[i+1]的元素,若i<=W-1,该点即为极大值点,对应算法流程第10-11行。

        

    3. NMS在物体检测中的应用

      物体检测中应用NMS算法的主要目的是消除多余(交叉重复)的窗口,找到最佳物体检测位置。

      

      如上图所示,人脸检测中,虽然每个窗口均检测到人脸,但仅需给出一个最有可能表征人脸的窗口。

    4. 算法程序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    function pickLocate = nms(boxes, overlap)
     
    % Non-maximum suppression.
    % In object detect algorithm, select high score detections and skip windows
    % covered by a previously selected detection.
    %
    % input - boxes : object detect windows.
    %                 xMin yMin xMax yMax score.
    %         overlap : suppression threshold.
    % output - pickLocate : number of local maximum score.
     
    boxes = double(boxes);
     
    if isempty(boxes)
        pickLocate = [];
    else
        xMin = boxes(:, 1);
        yMin = boxes(:, 2);
        xMax = boxes(:, 3);
        yMax = boxes(:, 4);
         
        s = boxes(:, end);
         
        % area of every detected windows.
        area = (xMax - xMin + 1) .* (yMax - yMin + 1);
         
        % sort detected windows based on the score.
        [vals, I] = sort(s);
         
        pickLocate = [];
        while ~isempty(I)
            last length(I);
            i = I(last);
             
            pickLocate = [pickLocate; i];
            suppress = [last];
             
            for pos = 1 : last - 1
                j = I(pos); 
                 
                % covered area.
                xx1 = max(xMin(i), xMin(j));
                yy1 = max(yMin(i), yMin(j));
                xx2 = min(xMax(i), xMax(j));
                yy2 = min(yMax(i), yMax(j));
                 
                w = xx2 - xx1 + 1;
                h = yy2 - yy1 + 1;
                 
                if ((w > 0) && (h > 0))
                    % compute overlap.
                    o = w * h / min(area(i), area(j));
                     
                    if (o > overlap)
                        suppress = [suppress; pos];
                    end
                end
                 
                % xx1 = max(x1(i), x1(I(1:last-1)));
                % yy1 = max(y1(i), y1(I(1:last-1)));
                % xx2 = min(x2(i), x2(I(1:last-1)));
                % yy2 = min(y2(i), y2(I(1:last-1)));
                 
                % w = max(0.0, xx2-xx1+1);
                % h = max(0.0, yy2-yy1+1);
                 
                % inter = w.*h;
                % o = inter ./ (area(i) + area(I(1:last-1)) - inter);
                 
                % saving the windows which o less than threshold.
                % I = I(o <= overlap);
            end
            I(suppress) = [];
        end
    end
    展开全文
  • 非极大值抑制算法详解

    千次阅读 2020-11-22 17:43:21
    目录非极大值抑制算法详解简介非极大值抑制算法符号介绍NMS的基本思路torch版本的NMS代码实现补充---numpy版本的NMS实现细节 简介  先简单介绍下极大值抑制(NMS),其目的是用来去除冗余的检测框。举个例子:以voc...

    非极大值抑制算法详解

    简介

     先简单介绍下非极大值抑制(NMS),其目的是用来去除冗余的检测框。举个例子:以voc2007数据集中单张图像为例,假设下图中绿色框为各个汽车的真实框,而红色框也是正样本框,但是我们最终希望输出仅仅包含绿色框的检测对象。因此为了抑制这部分红色框,采用非极大值抑制。

    图1图1

    非极大值抑制算法

    符号介绍

     首先利用torch(不是numpy)实现下上述过程矩形框的NMS。首先读取图1(a)中的图像和八个矩形框。为了叙述方便,这8个框按照[T,F,T,F,T,F,T,F]顺序排列,即最终检测结果是只剩下四个T真实框。如下所示:boxes用二维tensor表示。Scores表示每个box的置信度分数(为了符合上述[T,F]的设定,下面标红的数字比后面的淡蓝色的数值高,也就是抑制掉较低分数的box)。

    boxes=torch.Tensor([[12,311,84,362],[10,300,80,360],
                        [362,330,500,389],[360,330,500,380],
                        [175,327,252,364],[170,320,250,360],
                        [108,325,150,353], [100,320,150,350]])
    scores=torch.Tensor([0.99,0.98,0.89,0.88,0.79,0.78,0.69,0.68])
    

    NMS的基本思路

     B)首先将每个框置信度分数按照降序排序,首先保存一个置信度分数最大的box,然后计算剩下box和第一个box的iou,若某个框iou>=thr,就认为这两个框重合了,则舍弃掉。

    torch版本的NMS代码实现

    import numpy as np
    import torch
    import cv2
    
    def box_nms(boxes, scores, thr=0.2):
        '''
        boxes: [?,4]
        scores: [?]
        '''
        if boxes.shape[0] == 0:                              #若无预测框,则直接返回0.
            return torch.zeros(0, device=boxes.device).long()
        assert boxes.shape[-1] == 4
        x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
        areas = (x2 - x1 + 1) * (y2 - y1 + 1)                #计算八个矩形框的面积:tensor([3796., 4331.,...,1581])
        order = scores.sort(0, descending=True)[1]           #置信度分数降序排序,order是由大到小的下标排序[0,1,2,...,7]
        keep = []                                            #存储最终保存哪个预测框
        while order.numel() > 0:                             #若order里面一直有框,则一直循环
            if order.numel() == 1:                           #若仅有一个框,则直接将其作为最终的预测框并break
                i = order.item()
                keep.append(i)
                break
            else:                                            #若order中框的数量>=2
                i = order[0].item()
                keep.append(i)                               #首先往keep里面添加order中第一个,置信度分数最高的一个
            xmin = x1[order[1:]].clamp(min=float(x1[i]))
            ymin = y1[order[1:]].clamp(min=float(y1[i]))
            xmax = x2[order[1:]].clamp(max=float(x2[i]))
            ymax = y2[order[1:]].clamp(max=float(y2[i]))
            inter = (xmax - xmin).clamp(min=0) * (ymax - ymin).clamp(min=0)#并行计算交面积
            iou = inter / (areas[i] + areas[order[1:]] - inter)#计算iou
            idx = (iou <= thr).nonzero().squeeze()             #将iou值>=thr的抑制掉,仅保留阈值小的。
            if idx.numel() == 0:                               #若idx为0,则说明后面的框均被抑制掉,结束循环
                break
            order = order[idx + 1]                             #否则继续执行order下一个。
        return torch.LongTensor(keep)
    
    if __name__ == '__main__':
        devices = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
        img = cv2.imread('E:\Z_summary_elllipsenet/000004.jpg')
        boxes=torch.Tensor([[12,311,84,362],[10,300,80,360],
                            [362,330,500,389],[360,330,500,380],
                            [175,327,252,364],[170,320,250,360],
                            [108,325,150,353], [100,320,150,350]])
        scores=torch.Tensor([0.99,0.98,0.89,0.88,0.79,0.78,0.69,0.68])
        keep=box_nms(boxes,scores)
        print(boxes[keep])
    

     以第一次循环为例:首先order=[0,1,2,3,4,5,6,7],进入while循环后,keep=[0],也就是添加置信度分数最高的box进行了保存。之后计算第一个框和剩下7个box的iou,故iou的shape=[7]。然后通过一个判断语句==idx = (iou <= thr).nonzero().squeeze()==故将iou中<=thr的box保留了下来,且返回的是iou的下标。即idx=[1,2,3,4,5,6]。之后步入到黄色代码片段,order=order[idx+1],即此时order=[2,3,4,5,6,7],然后步入下一次循环。所以,order=order[idx+1]的目的是为了和最初的order[0,1,2,3,4,5,6,7]下标一一对应。毕竟你事先存储了一个仅keep,所以下标总体加1。

    补充—numpy版本的NMS实现

    import numpy as np
    
    def py_cpu_nms(dets, thresh=0.2):
        """Pure Python NMS baseline."""
        x1 = dets[:, 0]
        y1 = dets[:, 1]
        x2 = dets[:, 2]
        y2 = dets[:, 3]
        scores = dets[:, 4]
        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
        order = scores.argsort()[::-1]         # numpy降序排序
        keep = []
        while order.size > 0:
            i = order[0]
            keep.append(i)
            xx1 = np.maximum(x1[i], x1[order[1:]])
            yy1 = np.maximum(y1[i], y1[order[1:]])
            xx2 = np.minimum(x2[i], x2[order[1:]])
            yy2 = np.minimum(y2[i], y2[order[1:]])
            w = np.maximum(0.0, xx2 - xx1 + 1)
            h = np.maximum(0.0, yy2 - yy1 + 1)
            inter = w * h
            ovr = inter / (areas[i] + areas[order[1:]] - inter)
            inds = np.where(ovr <= thresh)[0]
            order = order[inds + 1]
        return keep
    if __name__ == '__main__':
        dets=np.array([[12,311,84,362,0.99],[10,300,80,360,0.98],
                            [362,330,500,389,0.89],[360,330,500,380,0.88],
                            [175,327,252,364,0.79],[170,320,250,360,0.78],
                            [108,325,150,353,0.69], [100,320,150,350,0.68]])
        scores=np.array([0.99,0.98,0.89,0.88,0.79,0.78,0.69,0.68])
        keep=py_cpu_nms(dets)
        print(keep)
    

    细节

     思考一个问题:假如存在两个不同类别的且重合度极高的两个box,那么最终输出结果这两个box都应该被保留,但是在上述NMS过程中,很显然只是针对同一类别下的NMS。假如在外层增加一个多个类别的话,但是这样运行速度会变慢,因此,实际在调用NMS函数之前,多加了一步操作:

    if __name__ == '__main__':
        boxes=torch.Tensor([[12,311,84,362],[10,300,80,360],          # 假设box均为同类别的
                            [362,330,500,389],[360,330,500,380],
                            [175,327,252,364],[170,320,250,360],
                            [108,325,150,353], [100,320,150,350]])
        scores=torch.Tensor([0.99,0.98,0.89,0.88,0.79,0.78,0.69,0.68])
        # 假设我在这儿增加一步:让不同类别的box远离一下。
        max_coordinate = boxes.max()       # max_coordinate = 500
        cls=torch.Tensor([1,2,1,1,1,1,1,1])# 假设八个boxes中有两种类别1和2
        offsets = cls.to(boxes) * (max_coordinate + 1)
        boxes_for_nms = boxes + offsets[:, None]
        print('不同类别下的新boxes:',boxes_for_nms)
    

     一般boxes的类别cls为[1,2,3…,20]整数,所以,通过cls*boxes中最大值作为offset,反加到boxes上,即可以将相同类别的boxes聚集在一起,而将不同类别的boxes远离。

    展开全文
  • 1、非极大值抑制算法提出的目的  在目标检测中,为了消除多余的检测框,找到最佳的物体检测的位置。   2、 极大值抑制(Non-Maximum Suppresion, NMS) 什么是非极大值抑制  极大值抑制(Non-...

    1、非极大值抑制算法提出的目的

             在目标检测中,为了消除多余的检测框,找到最佳的物体检测的位置。

     

    2、 非极大值抑制(Non-Maximum Suppresion, NMS)

    • 什么是非极大值抑制

            非极大值抑制(Non-Maximum Suppression,NMS),顾名思义就是抑制不是极大值的元素,可以理解为局部最大搜索。这个局部代表的是一个邻域,邻域有两个参数可变,一是邻域的维数,二是邻域的大小。此处主要说明NMS用于目标检测中提取分数最高的窗口的。例如在行人检测中,滑动窗口经提取特征,经分类器分类识别后,每个窗口都会得到一个分数。但是滑动窗口会导致很多窗口与其他窗口存在包含或者大部分交叉的情况。这时就需要用到NMS来选取那些邻域里分数最高(是行人的概率最大),并且抑制那些分数低的窗口。NMS在计算机视觉领域有着非常重要的应用,如视频目标跟踪、数据挖掘、3D重建、目标识别以及纹理分析等。

    • 思想:

             选取那些邻域里分数最高的窗口,同时抑制那些分数低的窗口。

    • 原理分析:

            对所有检测到的检测框按照他们的得分进行排序(这个得分就是我们利用分类器来进行时,会得到一个概率值,这个概率值就表示当前检测框是我们所需要检测目标的概率大小。)选出得分最大的检测框A,设定阈值b,在剩下的检测框中,计算他们与最大检测框A之间的IoU(Intersection over Union,若IoU大于阈值b,即重叠率高的检测框。删除这些检测框;有可能存在与当前检测框完全不重叠的,或者他们的重叠面积非常小(IoU小于阈值b),接下来会对这些没有处理过的检测框重新进行排序,排序完成后同样选择一个得分最大的检测框,然后计算其他检测框与这个最大检测框的IoU值,然后将IoU大于一定阈值的检测框再进行一次删除,不断的迭代这个过程,直到所有的检测框都被处理之后,输出最后的检测结果。

    3、NMS在目标检测中应用实例

     

    • 去除人脸检测中的重叠框:我们的目的就是要去除冗余的检测框,保留最好的一个

     

    face box

     

    • 目标检测 pipline

            产生proposal(区域)后使用分类网络给出每个框的每类置信度,使用回归网络修正位置,最终应用NMS。

    obj-det-pipline

     

    4、NMS改进的方法——Soft-NMS

    • 相邻区域内的检测框的分数进行调整而非彻底抑制,从而提高了高检索率情况下的准确率
    • 在低检索率时仍能对物体检测性能有明显提升

     

    改进方法在于将置信度改为IoU的函数:f(IoU),具有较低的值而不至于从排序列表中删去。即公式的第二项由0改成现在的第二项。

    • 在基于proposal方法的模型结果上应用比较好,检测效果提升:

    • 在YOLO、SSD等非proposal上没有提升。

     

    展开全文
  • 非极大值抑制算法hard-NMS与soft-NMS

    千次阅读 2019-06-18 15:53:17
    非极大值抑制算法(Non-maximum suppression, NMS)是有anchor系列目标检测的标配,如今大部分的One-Stage和Two-Stage算法在推断(Inference)阶段都使用了NMS作为网络的最后一层,例如YOLOv3、SSD、Faster-RCNN等。...

    前言

    非极大值抑制算法(Non-maximum suppression, NMS)是有anchor系列目标检测的标配,如今大部分的One-StageTwo-Stage算法在推断(Inference)阶段都使用了NMS作为网络的最后一层,例如YOLOv3、SSD、Faster-RCNN等。

    当然NMS在目前最新的anchor-free目标检测算法中(CornerNet、CenterNet等)并不是必须的,对这种检测算法提升的精度也有限,但是这并不影响我们学习NMS。

    NMS的本质是搜索局部极大值,抑制非极大值元素,在目标检测中,我们经常将其用于消除多余的检测框(从左到右消除了重复的检测框,只保留当前最大confidence的检测框):

    ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    NMS有很多种变体,这里介绍最为常见的Hard-NMS,我们通常所说的NMS就是指Hard-NMS,还有另外一种NMS叫做Soft-NMS,是Hard-NMS的变体,两者的代码几乎相同,只需要改动一个地方。

    Hard-NMS

    Hard-NMS就是我们传统意义上的NMS,也是最常用的NMS算法。

    因为NMS主要用于消除多余的检测框,那么消除的标准是什么,我们使用IOU作为标准来进行演示,IOU的原称为Intersection over Union,也就是两个box区域的交集比上并集,下图可以方便理解:

                  ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    具体介绍可以看这里:https://blog.csdn.net/qq_36338754/article/details/92794397

    Pytorch实现:

    def hard_nms(box_scores, iou_threshold, top_k=-1, candidate_size=200):
        """
        Args:
            box_scores (N, 5): box的集合,N为框的数量,5即4(位置信息)+1(可能为物体的概率)
            iou_threshold: 我们用IOU标准去除多余检测框的阈值
            top_k: 保留多少个计算后留下来的候选框,如果为-1则全保留
            candidate_size: 参与计算的boxes数量
        Returns:
             picked: 经过nms计算后保留下来的box
        """
        scores = box_scores[:, -1]                # 首先我们取出box中的最后一个元素也就是当前box检测到物体的概率
        boxes = box_scores[:, :-1]                # 取出box中的四个坐标(左上、右下)
        picked = []  
        _, indexes = scores.sort(descending=True) # 按照降序排列所有的物体的概率,得到排序后在原数组中的索引信息 indexes
        indexes = indexes[:candidate_size]        # 只保留前 candidate_size 个 boxes 其余的不考虑了
        while len(indexes) > 0:
            current = indexes[0]                  # 每次取出当前在 indexes 中 检测到物体概率最大的一个 
            picked.append(current.item())         # 将这个最大的存在结果中
            if 0 < top_k == len(picked) or len(indexes) == 1:
                break
            current_box = boxes[current, :]       # 当前第一个也就是最高概率的box
            indexes = indexes[1:]                
            rest_boxes = boxes[indexes, :]        # 剩下其余的box
            iou = iou_of(                         # 将当前的box与剩下其余的boxes用IOU标准进行筛选
                rest_boxes,
                current_box.unsqueeze(0),
            )
            indexes = indexes[iou <= iou_threshold]# 保留与当前box的IOU小于一定阈值的boxes,
    
        return box_scores[picked, :]

    看了上面的代码,我们可以知道大概的流程:

    • 选取这类box中scores最大的那一个,记为current_box,并保留它(为什么保留它,因为它预测出当前位置有物体的概率最大啊,对于我们来说当前confidence越大说明当前box中包含物体的可能行就越大)
    • 计算current_box与其余的box的IOU
    • 如果其IOU大于我们设定的阈值,那么就舍弃这些boxes(由于可能这两个box表示同一目标,因此这两个box的IOU就比较大,会超过我们设定的阈值,所以就保留分数高的那一个)
    • 从最后剩余的boxes中,再找出最大scores的那一个(之前那个大的已经保存到输出的数组中,这个是从剩下的里面再挑一个最大的),如此循环往复

    至于上述代码中iou_of部分:

    def area_of(left_top, right_bottom) -> torch.Tensor:
        """Compute the areas of rectangles given two corners.
    
        Args:
            left_top (N, 2): left top corner.
            right_bottom (N, 2): right bottom corner.
    
        Returns:
            area (N): return the area.
        """
        hw = torch.clamp(right_bottom - left_top, min=0.0)
        return hw[..., 0] * hw[..., 1]
    
    
    def iou_of(boxes0, boxes1, eps=1e-5):
        """Return intersection-over-union (Jaccard index) of boxes.
    
        Args:
            boxes0 (N, 4): ground truth boxes.
            boxes1 (N or 1, 4): predicted boxes.
            eps: a small number to avoid 0 as denominator.
        Returns:
            iou (N): IoU values.
        """
        overlap_left_top = torch.max(boxes0[..., :2], boxes1[..., :2])
        overlap_right_bottom = torch.min(boxes0[..., 2:], boxes1[..., 2:])
    
        overlap_area = area_of(overlap_left_top, overlap_right_bottom)
        area0 = area_of(boxes0[..., :2], boxes0[..., 2:])
        area1 = area_of(boxes1[..., :2], boxes1[..., 2:])
        return overlap_area / (area0 + area1 - overlap_area + eps)

    Soft-NMS

    NMS是最常用的目标检测后处理算法,但是NMS对于密集目标的检测就有小问题了,因为NMS是对其他box的iou与当前最大confidence的box的iou进行比较,如果大于一定的阈值,就将当前这个confidence最大的box周围满足条件的box给去掉。

    通常情况普通NMS是可行的,但是有些情况,比如在相似目标离的比较近的时候,使用NMS就会出现:

              ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    上图中,由于红框和绿框的IOU大于了一定的阈值(假如我们设定了0.4),然后绿色框框的confidence没有红色框框的高,然后经过nms后,就没了…你会说我们可以改变阈值啊,比如从0.4改成0.5,要求高一点,但是这个阈值高了的话,可能就会导致误检了,这个阈值设置永远不可能完美。

    也就是说,如果目标比较密集的话,这个时候就需要Soft-nms了:

                        ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    那Soft-NMS和NMS的区别就在于改动了一个地方,在判断当前最高confidence的box和其余box的IOU的时候加了一个系数,这个系数可以让我们更好地选择要去掉的多余的box。

    对于Hard-NMS来说,当最大confidence与其余box的IOU大于一定的阈值,这些多余的box就消失了:

                                                            ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    而在Soft-NMS中,对于与最大confidence的box相比iou大于一定阈值的框乘以一个与IOU相关的系数,最终得到更新后的iou值:

                                                ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    或者是这种形式:

                                                                    ãææéæ大å¼æå¶ç®æ³NMSä¸soft-NMSã

    看到这里可能还不清楚,我们继续看看下面的代码:

    def soft_nms(box_scores, score_threshold, sigma=0.5, top_k=-1):
        """Soft NMS implementation.
    
        References:
            https://arxiv.org/abs/1704.04503
            https://github.com/facebookresearch/Detectron/blob/master/detectron/utils/cython_nms.pyx
    
        Args:
            box_scores (N, 5): boxes in corner-form and probabilities.
            score_threshold: boxes with scores less than value are not considered.
            sigma: the parameter in score re-computation.
                scores[i] = scores[i] * exp(-(iou_i)^2 / simga)
            top_k: keep top_k results. If k <= 0, keep all the results.
        Returns:
             picked_box_scores (K, 5): results of NMS.
        """
        picked_box_scores = []
        while box_scores.size(0) > 0:
            max_score_index = torch.argmax(box_scores[:, 4])
            cur_box_prob = torch.tensor(box_scores[max_score_index, :])
            picked_box_scores.append(cur_box_prob)
            if len(picked_box_scores) == top_k > 0 or box_scores.size(0) == 1:
                break
            cur_box = cur_box_prob[:-1]
            box_scores[max_score_index, :] = box_scores[-1, :]
            box_scores = box_scores[:-1, :]
            ious = iou_of(cur_box.unsqueeze(0), box_scores[:, :-1])
    
            # 以下这句是新加的,如果没有这句就是Hard-NMS了
            box_scores[:, -1] = box_scores[:, -1] * torch.exp(-(ious * ious) / sigma) 
    
            box_scores = box_scores[box_scores[:, -1] > score_threshold, :]
        if len(picked_box_scores) > 0:
            return torch.stack(picked_box_scores)
        else:
            return torch.tensor([])

    Hard-NMS与Soft-NMS的区别不大,Soft-NMS对于Hard-NMS也没有特别多的计算量,所以在实际中,我们尽量使用Soft-NMS就好。

    展开全文
  • NMS-非极大值抑制算法总结greedy-nms、soft-nms标准极大值抑制 - NMS软阈值NMS - soft-NMS greedy-nms、soft-nms greedy-NMS是最传统的(标准)的非极大值抑制算法,soft-NMS是前者的改进版本。下面将分别从两者的...
  • 非极大值抑制算法 (NMS)

    千次阅读 2017-06-02 21:54:38
     非极大值抑制算法(Non-maximum suppression, NMS)的本质是搜索局部极大值,抑制极大值元素。 2. 3邻域情况下NMS的实现  3邻域情况下的NMS即判断一维数组I[W]的元素I[i](2    a. 算法流程3-5行判断...
  • NMS—非极大值抑制算法的理解

    千次阅读 2018-10-13 13:33:03
    非极大值抑制算法(NMS)对多个候选框,去除重合率大的冗余候选框,得到最具代表性的结果,以加快目标检测的效率。 二、实例 以下图人脸检测为例,目标:消除重合率大且多余的候选框,保留某个区域的一个最优的候选...
  • 自适应非极大值抑制算法自适应非极大值抑制算法是论文Multi-Image Matching using Multi-Scale Oriented Patches提出的一种算法。基本思想是评估所有interesting point的极大区域,并进行排序。具体来说,就是先选取...
  • matlab下 非极大值抑制算法

    千次阅读 2014-04-24 09:22:28
     non-maximum suppression:非极大值抑制
  • 非极大值抑制算法(NMS)及python实现

    万次阅读 2018-01-20 11:55:12
    在目标检测中,常会利用非极大值抑制算法(NMS)对生成的大量候选框进行后处理,去除冗余的候选框,得到最具代表性的结果,以加快目标检测的效率。即如下图所示,消除多余的候选框,找到最佳的bbox。 NMS...
  • 非极大值抑制算法(matlab实现)

    千次阅读 2018-12-27 15:56:22
    参考:... function pickLocate = nms(boxes, overlap) % Non-maximum suppression. % In object detect algorithm, select high score detections and skip windows...
  • 所属知识点:Computer Vision:Object Detection归纳和总结机器学习技术的库:ViolinLee/ML_notes 关键概念:NMS;IOU;Bounding Box(BBox);...NMS 是一种让你确保算法只对每个对象得到一个...
  • Soft-NMS这样来解决这个问题,同一个物体周围的框有很多,每次选择分数最高的框,抑制其周围的框,与分数最高的框的IoU越抑制的程度越,一般来说,表示同一个物体的框(比如都是前面的马)的IoU是会比另一个...
  • 简介 非极大值抑制NMS算法c++版本 源码
  • 非极大值抑制(nms)算法详解[python]

    万次阅读 多人点赞 2019-08-22 17:29:59
    一、起源 目标检测在使用了基于深度学习的端到端模型后效果斐然。目前,常用的目标检测算法,无论是One-stage的SSD系列算法、YOLO系列算法还是Two-stage的基于RCNN系列的算法,极...非极大值抑制算法的目的正在于...
  • 非极大值抑制 NMS

    千次阅读 2017-04-06 10:22:14
    非极大值抑制算法(Non-maximum suppression, NMS)的本质是搜索局部极大值,抑制极大值元素。极大值抑制(NMS)主要在图像处理中的应用主要是是为了更精确的定位某种特征。举一个简单的例子:用梯度变化表征...
  • NMS非极大值抑制

    千次阅读 2016-09-12 11:00:05
    非极大值抑制算法 Non-Maximum Suppression for Object Detection in Python 非极大值抑制算法
  • Canny算法中的非极大值抑制

    千次阅读 2018-01-19 19:40:48
    Canny算子中的非极大值抑制(Non-Maximum Suppression)分析 ...在常见的边缘检测算子或轮廓检测相关算法中都有非极大值抑制这一步,然而对与非极大值抑制在这些边缘检测算子中应用,在理解可能有点似懂非懂
  • MOPS中ANMS(非极大值抑制算法讨论

    千次阅读 2015-04-29 00:23:24
    Matthew Brown等人在论文中提到使用自适应非极大值抑制(ANMS)算法对Harris角点检测所得到的大量关键点(Interest Point)做进一步筛选,以达到减少关键点数量,同时尽可能保持角点响应大的点,并且关键点分布均匀...
  • 目标检测非极大值抑制算法的原理及其代码实现
  • YOLO在最后的一个步骤就是对 SxSx(Bx5+C) 个向量进行非极大值抑制(Non-max suppression),一开始不是太明白非极大值抑制是如何操作的,也就是不太清楚YOLO最后做完卷积后如何对求得向量进行预测,求得目标框位置。...
  • nms--非极大值抑制

    千次阅读 2018-07-31 17:16:42
    nms(non maximum suppression) 非极大值抑制算法在检测任务中非常常用,常常会出现在同一个目标位置处产生多个候选框;因此nms的作用是剔除掉检测结果中重合率(IOU)大于给定阈值(threshold)的候选框,最终期望...
  • 背景:非极大值抑制算法(Non-maximum suppression, NMS)的本质是搜索局部极大值,抑制极大值元素。在目标检测之中用到非常多。 目的:搞懂此算法原理且看懂代码。 目录 一、算法解析 1.1 算法概览 1.2 算法...
  • FAST角点检测算法(二)- 非极大值抑制筛选fast特征点author@jason_ql(lql0716) http://blog.csdn.net/lql0716 fast角点检测算法参考文章《fast角点检测算法》(涵盖fast角点检测原理及C++、python代码,以及效果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,778
精华内容 6,311
关键字:

非极大值抑制算法