Расчет процента перекрытия ограничивающей рамки для оценки детектора изображения

Для ограничивающих прямоугольников, выровненных по оси, это относительно просто. «Выровнено по оси» означает, что ограничивающая рамка не поворачивается; или, другими словами, линии прямоугольников параллельны осям. Вот как рассчитать IoU двух ограничивающих прямоугольников, выровненных по оси.

def get_iou(bb1, bb2):
    """
    Calculate the Intersection over Union (IoU) of two bounding boxes.

    Parameters
    ----------
    bb1 : dict
        Keys: {'x1', 'x2', 'y1', 'y2'}
        The (x1, y1) position is at the top left corner,
        the (x2, y2) position is at the bottom right corner
    bb2 : dict
        Keys: {'x1', 'x2', 'y1', 'y2'}
        The (x, y) position is at the top left corner,
        the (x2, y2) position is at the bottom right corner

    Returns
    -------
    float
        in [0, 1]
    """
    assert bb1['x1'] < bb1['x2']
    assert bb1['y1'] < bb1['y2']
    assert bb2['x1'] < bb2['x2']
    assert bb2['y1'] < bb2['y2']

    # determine the coordinates of the intersection rectangle
    x_left = max(bb1['x1'], bb2['x1'])
    y_top = max(bb1['y1'], bb2['y1'])
    x_right = min(bb1['x2'], bb2['x2'])
    y_bottom = min(bb1['y2'], bb2['y2'])

    if x_right < x_left or y_bottom < y_top:
        return 0.0

    # The intersection of two axis-aligned bounding boxes is always an
    # axis-aligned bounding box
    intersection_area = (x_right - x_left) * (y_bottom - y_top)

    # compute the area of both AABBs
    bb1_area = (bb1['x2'] - bb1['x1']) * (bb1['y2'] - bb1['y1'])
    bb2_area = (bb2['x2'] - bb2['x1']) * (bb2['y2'] - bb2['y1'])

    # compute the intersection over union by taking the intersection
    # area and dividing it by the sum of prediction + ground-truth
    # areas - the interesection area
    iou = intersection_area / float(bb1_area + bb2_area - intersection_area)
    assert iou >= 0.0
    assert iou <= 1.0
    return iou

Объяснение

Изображения взяты из этого ответа

В ответе, получившем наибольшее количество голосов, есть математическая ошибка, если вы работаете с координатами экрана (пикселей)! Несколько недель назад я отправил правку с подробным объяснением для всех читателей, чтобы они поняли математику. Но это изменение не было понято рецензентами и было удалено, поэтому я снова отправил то же изменение, но на этот раз более кратко. (Обновление: Отклонено 2 на 1, потому что это было сочтено «существенным изменением», хех).

Поэтому я полностью объясню БОЛЬШУЮ проблему с ее математикой здесь, в этом отдельном ответе.

Итак, да, в общем, ответ, получивший наибольшее количество голосов, является правильным и является хорошим способом расчета IoU. Но (как указывали и другие люди) его математика совершенно неверна для экранов компьютеров. Вы не можете просто сделать (x2 - x1) * (y2 - y1), так как это вообще не приведет к правильному вычислению площади. Индексация экрана начинается с пикселя 0,0 и заканчивается width-1,height-1. Диапазон экранных координат inclusive:inclusive (включительно с обоих концов), поэтому диапазон от 0 до 10 в пиксельных координатах на самом деле имеет ширину 11 пикселей, потому что он включает 0 1 2 3 4 5 6 7 8 9 10 (11 элементов). Итак, чтобы вычислить площадь экранных координат, вы ДОЛЖНЫ добавить +1 к каждому измерению, как показано ниже: (x2 - x1 + 1) * (y2 - y1 + 1).

Если вы работаете в какой-либо другой системе координат, где диапазон не является исчерпывающим (например, в системе inclusive:exclusive, где от 0 до 10 означает «элементы от 0 до 9, но не 10»), тогда эта дополнительная математика НЕ ​​потребуется. Но, скорее всего, вы обрабатываете ограничивающие прямоугольники на основе пикселей. Ну, координаты экрана начинаются с 0,0 и идут вверх оттуда.

Экран 1920x1080 индексируется от 0 (первый пиксель) до 1919 (последний пиксель по горизонтали) и от 0 (первый пиксель) до 1079 (последний пиксель по вертикали).

Итак, если у нас есть прямоугольник в «пиксельном координатном пространстве», для вычисления его площади мы должны прибавить 1 в каждом направлении. В противном случае мы получим неправильный ответ при расчете площади.

Представьте, что наш 1920x1080 экран имеет прямоугольник на основе пиксельных координат с left=0,top=0,right=1919,bottom=1079 (покрывающий все пиксели на всем экране).

Что ж, мы знаем, что 1920x1080 пикселей - это 2073600 пиксель, что является правильной областью экрана 1080p.

Но с неправильной математикой area = (x_right - x_left) * (y_bottom - y_top) мы получим: (1919 - 0) * (1079 - 0) = 1919 * 1079 = 2070601 пикселей! Это неверно!

Вот почему мы должны добавлять +1 к каждому вычислению, что дает нам следующую исправленную математику: area = (x_right - x_left + 1) * (y_bottom - y_top + 1), что дает нам: (1919 - 0 + 1) * (1079 - 0 + 1) = 1920 * 1080 = 2073600 пикселей! И это действительно правильный ответ!

Кратчайшее из возможных резюме: Диапазоны пиксельных координат равны inclusive:inclusive, поэтому мы должны добавить + 1 к каждой оси, если нам нужна истинная область диапазона пиксельных координат.

Дополнительные сведения о том, зачем нужен +1, см. В ответе Джиндиля: https://stackoverflow.com/a/51730512/8874388

А также эта статья pyimagesearch: https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/

И этот комментарий GitHub: https://github.com/AlexeyAB/darknet/issues/3995#issuecomment-535697357

Поскольку фиксированная математика не была утверждена, любой, кто копирует код из ответа, получившего наибольшее количество голосов, надеется увидеть этот ответ и сможет исправить его самостоятельно, просто скопировав приведенные ниже утверждения с исправленными ошибками и строки расчета площади, которые были исправлено для диапазонов координат inclusive:inclusive (пикселей):

    assert bb1['x1'] <= bb1['x2']
    assert bb1['y1'] <= bb1['y2']
    assert bb2['x1'] <= bb2['x2']
    assert bb2['y1'] <= bb2['y2']

................................................

    # The intersection of two axis-aligned bounding boxes is always an
    # axis-aligned bounding box.
    # NOTE: We MUST ALWAYS add +1 to calculate area when working in
    # screen coordinates, since 0,0 is the top left pixel, and w-1,h-1
    # is the bottom right pixel. If we DON'T add +1, the result is wrong.
    intersection_area = (x_right - x_left + 1) * (y_bottom - y_top + 1)

    # compute the area of both AABBs
    bb1_area = (bb1['x2'] - bb1['x1'] + 1) * (bb1['y2'] - bb1['y1'] + 1)
    bb2_area = (bb2['x2'] - bb2['x1'] + 1) * (bb2['y2'] - bb2['y1'] + 1)

Простой способ для любого типа многоугольника.

(Изображение не масштабировано)

from shapely.geometry import Polygon


def calculate_iou(box_1, box_2):
    poly_1 = Polygon(box_1)
    poly_2 = Polygon(box_2)
    iou = poly_1.intersection(poly_2).area / poly_1.union(poly_2).area
    return iou


box_1 = [[511, 41], [577, 41], [577, 76], [511, 76]]
box_2 = [[544, 59], [610, 59], [610, 94], [544, 94]]

print(calculate_iou(box_1, box_2))

Результатом будет 0.138211..., что означает 13.82%.

Примечание. Источник систем координат в библиотеке shapely находится слева внизу, а источник в компьютерной графике - слева вверху. Это различие не влияет на расчет IoU, но эта информация может оказаться полезной при выполнении других типов расчетов.

Вы можете рассчитать с torchvision следующим образом. Bbox подготовлен в формате [x1, y1, x2, y2].

import torch
import torchvision.ops.boxes as bops

box1 = torch.tensor([[511, 41, 577, 76]], dtype=torch.float)
box2 = torch.tensor([[544, 59, 610, 94]], dtype=torch.float)
iou = bops.box_iou(box1, box2)
# tensor([[0.1382]])

Для расстояния пересечения не следует добавлять +1, чтобы иметь

intersection_area = (x_right - x_left + 1) * (y_bottom - y_top + 1)   

(то же самое для AABB)
Как на этом поисковое сообщение pyimage

Я согласен, что (x_right - x_left) x (y_bottom - y_top) работает в математике с координатами точки, но поскольку мы имеем дело с пикселями, я думаю, что это другое.

Рассмотрим одномерный пример:

• 2 балла: x1 = 1 и x2 = 3, расстояние действительно x2-x1 = 2
• 2 пикселя индекса: i1 = 1 и i2 = 3, сегмент от пикселя i1 до i2 содержит 3 пикселя, т.е. l = i2 - i1 + 1