在目标检测当中，有一个重要的概念就是 IOU。一般指代模型预测的 bbox 和 Groud Truth 之间的交并比。

何为交并比呢？

IOU = \frac{A\cap B}{A\cup B}IOU=A∪BA∩B​



集合 A 和集合 B 的并集包括了上面 3 种颜色区域。

集合 C 是集合 A 与集合 B 的交集。

在目标检测当中，IOU 就是上面两种集合的比值。

A \cup BA∪B 其实就是 A + B - CA+B−C。

那么公式可以转变为：

IOU = \frac{A \cap B}{A + B - (A \cap B)}IOU=A+B−(A∩B)A∩B​

IOU 衡量两个集合的重叠程度。

IOU 为 0 时，两个框不重叠，没有交集。
	
IOU 为 1 时，两个框完全重叠。
	
IOU 取值为 0 ～ 1 之间的值时，代表了两个框的重叠程度，数值越高，重叠程度越高。
在 2D 目标检测当中，因为 bbox 是矩形，所以很容易求得 IOU。

方框 A 和 B 相交，典型的情况如下：



A 和 B 的面积容易求得，C 的面积稍微繁琐一点，但耐心细致的话可以求得。

如果利用数学思维，细心整理，可以发现面积 C 只需要求得边长的乘积就好，即使 A 和 B 的位置是相对的，但稍加变换也能够求出。

如果以 W 代表 A 和 B 的交集 C 的 x 轴方向上的边长，那么有

W = min(A.x_{1},B.x_{1}) - max(A.x_{0},B.x_{0})W=min(A.x1​,B.x1​)−max(A.x0​,B.x0​)

同理，

H = min(A.y_{1},B.y_{1}) - max(A.y_{0},B.y_{0})H=min(A.y1​,B.y1​)−max(A.y0​,B.y0​)

大家仔细观察上面的对应关系，可以发现公式是成立的。这个公式的推导并不难，无非是 4 个顶点的坐标的相对位置变换，大家可以自行琢磨。

如果 A 与 B 根本就不相交。


这个时候可以发现 W <= 0 或 H <= 0.

下面是 Python 代码。

class BBox:
    def __init__(self,x,y,w,h):
        self.x = x
        self.y = y
        self.w = w
        self.h = h

def iou(a,b):

    assert isinstance(a,BBox)
    assert isinstance(b,BBox)

    area_a = a.w * a.h
    area_b = b.w * b.h

    w = min(b.x+b.w,a.x+a.w) - max(a.x,b.x)
    h = min(b.y+b.h,a.y+a.h) - max(a.y,b.y)

    if w <= 0 or h <= 0:
        return 0

    area_c = w * h

    return area_c / (area_a + area_b - area_c)



if __name__ == '__main__':

    a = BBox(1,1,4,5)
    b1 = BBox(1,1,4,5)
    b2 = BBox(5,1,4,5)
    b3 = BBox(3,2,3,6)


    print("iou ",iou(a,b1))
    print("iou ",iou(a,b2))
    print("iou ",iou(a,b3))


运行结果如下：

iou  1.0
iou  0
iou  0.26666666666666666

再加上个DIOU  等等吧

还有GIOU相比iou的优点 哈哈

https://www.cnblogs.com/dengshunge/p/12252820.html 

  杰卡德（Jaccard）相似系数
 
 这种相似度计算方式相对简单，原理也易于理解，就是计算单词集合之间的交集和并集大小的比例，该值越大，表示两个文本越相似。在涉及到大规模并行计算时，该方法效率上有一定的优势。


Jaccard
 相似度公式：
举例：
句子A：“我喜欢看电视，不喜欢看电影。”
句子B：“我不喜欢看电视，也不喜欢看电影。” 
分词去噪后：A=（我，喜欢，看，电视，电影，不） 
 B=（我，喜欢，看，电视，电影，也，不）
那么J(A,B)=(我，喜欢，看，电视，电影，不)/(我，喜欢，看，电视，电影，也，不)=6/7=0.86


余弦（Cosine）相似度
 
 余弦相似度是利用计算两个向量之间的夹角，夹角越小相似度越高，其公式为：
假定A和B是两个n维向量，A是[A1,A2,...,An],B是[B1,B2,B3,...,Bn],则A与B的夹角余弦等于：

 
 沿用上面的例子，计算词频如下：
句子A：我
 1，喜欢 2，看 2，电视 1，电影 1， 不 1，也 0。
句子B：我
 1，喜欢 2，看 2，电视 1，电影 1，不 2，也 1。
写出词频向量:
句子A:[1,2,2,1,1,1,0] 
    句子B:[1,2,2,1,1,2,1]
使用上述公式，我们可以得到句子A与句子B的夹角余弦。




海量数据的相似度
    海联数据的相似度计算直接使用上面两种办法效率未免有些太低了，可以参考
 simhash 算法.其核心思路就是想办法缩小问题规模，之后再进行比对。
提供一下几个参考链接学习：
 
   1.Similarity estimation techniques from rounding algorithms
 
    2.simhash与Google的网页去重
       3.海量数据相似度计算之simhash和海明距离
 

1. jarcard距离

公式：有字符串A和字符串B,A和B所含字符的交集/A和B所含字符的并集，就是两句话的相识度。

2. 编辑距离

公式：有字符串A和B, 字符串A需要变成字符串B需要使用的编辑的步数N，编辑的方式可以是增加，删除, 字符串A和B中的最大的字符长度为L, 那么两句话的相识度为：1 - N/L

3. 将语句装换成句向量，通过计算向量间的距离来计算相识度。

步骤：1.分词处理

           2.去停词处理

           3.使用gensim，将词转成词向量

           4.将词向量转成句向量

           5.对向量X进行hash值处理，(X*W+B)/S,将其存在数组中，若存在相同位置的字符串通过链表存储，以上是待匹配的字符串的存储

           6.将待匹配的字符串也经过上面的步骤得到hash值，索引数组中的位置，若该位置有多个字符串，可在再通过欧式距离求相似度。若不存在，可找相邻位置上的字符串。

将词向量转句向量的方法：

1. 分词累加厚求平均值的方式

2. 使用tf-idf做加权平均

3. 使用词移距离，计算一个字符串中一个词到另一个字符串中所有词的距离之和，可以使用if-idf作为权重



4. 使用seq2seq模型来生成句向量

使用中间上下文C，作为句向量

本文系转载，出处：http://www.manongjc.com/article/37951.html
交并比（Intersection-over-Union，IoU），目标检测中使用的一个概念，是产生的候选框（candidate bound）与原标记框（ground truth bound）的交叠率，即它们的交集与并集的比值。最理想情况是完全重叠，即比值为1。


计算公式：

代码实现1：
def calculateIoU(candidateBound, groundTruthBound):
    cx1 = candidateBound[0]
    cy1 = candidateBound[1]
    cx2 = candidateBound[2]
    cy2 = candidateBound[3]

    gx1 = groundTruthBound[0]
    gy1 = groundTruthBound[1]
    gx2 = groundTruthBound[2]
    gy2 = groundTruthBound[3]

    carea = (cx2 - cx1) * (cy2 - cy1) #C的面积
    garea = (gx2 - gx1) * (gy2 - gy1) #G的面积

    x1 = max(cx1, gx1)
    y1 = max(cy1, gy1)
    x2 = min(cx2, gx2)
    y2 = min(cy2, gy2)
    w = max(0, x2 - x1)
    h = max(0, y2 - y1)
    area = w * h #C∩G的面积

    iou = area / (carea + garea - area)

    return iou

代码实现2：
import numpy as np
def compute_iou(box1, box2, wh=False):
    """
    compute the iou of two boxes.
    Args:
        box1, box2: [xmin, ymin, xmax, ymax] (wh=False) or [xcenter, ycenter, w, h] (wh=True)
        wh: the format of coordinate.
    Return:
        iou: iou of box1 and box2.
    """
    if wh == False:
        xmin1, ymin1, xmax1, ymax1 = box1
        xmin2, ymin2, xmax2, ymax2 = box2
    else:
        xmin1, ymin1 = int(box1[0]-box1[2]/2.0), int(box1[1]-box1[3]/2.0)
        xmax1, ymax1 = int(box1[0]+box1[2]/2.0), int(box1[1]+box1[3]/2.0)
        xmin2, ymin2 = int(box2[0]-box2[2]/2.0), int(box2[1]-box2[3]/2.0)
        xmax2, ymax2 = int(box2[0]+box2[2]/2.0), int(box2[1]+box2[3]/2.0)

    ## 获取矩形框交集对应的左上角和右下角的坐标（intersection）
    xx1 = np.max([xmin1, xmin2])
    yy1 = np.max([ymin1, ymin2])
    xx2 = np.min([xmax1, xmax2])
    yy2 = np.min([ymax1, ymax2])

    ## 计算两个矩形框面积
    area1 = (xmax1-xmin1) * (ymax1-ymin1) 
    area2 = (xmax2-xmin2) * (ymax2-ymin2)

    inter_area = (np.max([0, xx2-xx1])) * (np.max([0, yy2-yy1]))　#计算交集面积
    iou = inter_area / (area1+area2-inter_area+1e-6)　＃计算交并比

    return iou

在目标检测中，常会利用非极大值抑制算法(NMS)对生成的大量候选框进行后处理，去除冗余的候选框，得到最具代表性的结果，以加快目标检测的效率。NMS其实是为了消除多余的候选框，找到最佳的bbox。
NMS的算法逻辑为：
for object in all objects:
    (1) 获取当前目标类别下所有bbx的信息
    (2) 将bbx按照confidence从高到低排序,并记录当前confidence最大的bbx
    (3) 计算最大confidence对应的bbx与剩下所有的bbx的IOU,移除所有大于IOU阈值的bbx
    (4) 对剩下的bbx，循环执行(2)和(3)直到所有的bbx均满足要求（即不能再移除bbx）

代码实现：
import numpy as np

class Bounding_box:
    def __init__(self, x1, y1, x2, y2, score):
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2
        self.score = score

def get_iou(boxa, boxb):
    max_x = max(boxa.x1, boxb.x1)
    max_y = max(boxa.y1, boxb.y1)
    min_x = min(boxa.x2, boxb.x2)
    min_y = min(boxa.y2, boxb.y2)
    if min_x <= max_x or min_y <= max_y:
        return 0
    area_i = (min_x - max_x) * (min_y - max_y)
    area_a = (boxa.x2 - boxa.x1) * (boxa.y2 - boxa.y1)
    area_b = (boxb.x2 - boxb.x1) * (boxb.y2 - boxb.y1)
    area_u = area_a + area_b - area_i
    return float(area_i) / float(area_u)

def NMS(box_lists, k):
    box_lists = sorted(box_lists, key=lambda x: x.score, reverse=True)
    NMS_lists = [box_lists[0]]
    temp_lists = []
    for i in range(k):
        for j in range(1, len(box_lists)):
            iou = get_iou(NMS_lists[i], box_lists[j])
            if iou < 0.7:
                temp_lists.append(box_lists[j])
        if len(temp_lists) == 0:
            return NMS_lists
        box_lists = temp_lists
        temp_lists = []
        NMS_lists.append(box_lists[0])
    return NMS_lists

box1 = Bounding_box(13, 22, 268, 367, 0.124648176)
box2 = Bounding_box(18, 27, 294, 400, 0.35818103)
box3 = Bounding_box(234, 123, 466, 678, 0.13638769)
box_lists = [box1, box2, box3]
NMS_list = NMS(box_lists, 2)
print NMS_list
print NMS_list[0].x1