Оценка моделей обнаружения объектов с использованием средней средней точности (mAP)
Для оценки моделей обнаружения объектов, таких как R-CNN и YOLO, используется средняя средняя точность (mAP). mAP сравнивает ограничивающую рамку основной истины с обнаруженной рамкой и возвращает оценку. Чем выше оценка, тем точнее модель в своих обнаружениях.
В моей последней статье мы подробно рассмотрели матрицу путаницы, точность модели, прецизионность и полноту. Для расчета этих показателей мы также использовали библиотеку Scikit-learn. Теперь мы расширим наше обсуждение и посмотрим, как точность и полнота используются для расчета mAP.
Вот разделы, рассматриваемые в этом руководстве:
- От оценки прогноза к метке класса
- Кривая точного отзыва
- Средняя точность (AP)
- Пересечение через Союз (IoU)
- Средняя средняя точность (mAP) обнаружения объектов
Предварительные условия
Чтобы следовать этой статье, ознакомьтесь с опытом работы с кодом Python и начинающим пониманием глубокого обучения. Мы будем исходить из предположения, что все читатели имеют доступ к достаточно мощным машинам, чтобы они могли запускать предоставленный код.
Если у вас нет доступа к графическому процессору, мы предлагаем получить к нему доступ через облако. Существует множество облачных провайдеров, предлагающих графические процессоры. DigitalOcean GPU Droplets в настоящее время находится в ранней доступности. Узнайте больше и подпишитесь на интерес к GPU Droplets здесь.
Чтобы получить инструкции по началу работы с кодом Python, мы рекомендуем попробовать это руководство для начинающих, чтобы настроить систему и подготовиться к запуску руководств для начинающих.
От оценки прогноза к метке класса
В этом разделе мы кратко рассмотрим, как метка класса получается из прогнозируемой оценки.
Учитывая, что существует два класса: Положительный и Отрицательный, вот основные метки для 10 образцов.
y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative", "positive", "negative", "positive"]
Когда эти выборки передаются в модель, она возвращает следующие оценки прогноза. Как на основе этих оценок мы классифицируем образцы (т. е. присваиваем метку класса каждому образцу)?
pred_scores = [0.7, 0.3, 0.5, 0.6, 0.55, 0.9, 0.4, 0.2, 0.4, 0.3]
Чтобы преобразовать оценки в метку класса, используется пороговое значение. Когда оценка равна или превышает пороговое значение, выборка классифицируется как один класс. В противном случае он классифицируется как другой класс. Давайте договоримся, что выборка считается положительной, если ее оценка выше или равна пороговому значению. В противном случае это Отрицательно. Следующий блок кода преобразует оценки в метки классов с порогом 0,5.
import numpy
pred_scores = [0.7, 0.3, 0.5, 0.6, 0.55, 0.9, 0.4, 0.2, 0.4, 0.3]
y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative", "positive", "negative", "positive"]
threshold = 0.5
y_pred = ["positive" if score >= threshold else "negative" for score in pred_scores]
print(y_pred)
['positive', 'negative', 'positive', 'positive', 'positive', 'positive', 'negative', 'negative', 'negative', 'negative']
Теперь как основные, так и предсказанные метки доступны в переменных y_true и y_pred. На основе этих меток можно рассчитать матрицу путаницы, точность и полноту.
r = numpy.flip(sklearn.metrics.confusion_matrix(y_true, y_pred))
print(r)
precision = sklearn.metrics.precision_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
print(precision)
recall = sklearn.metrics.recall_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
print(recall)
Confusion Matrix (From Left to Right & Top to Bottom: True Positive, False Negative, False Positive, True Negative)
[[4 2]
[1 3]]
Precision = 4/(4+1)
0.8
Recall = 4/(4+2)
0.6666666666666666
После этого краткого обзора расчета точности и полноты в следующем разделе мы обсудим создание кривой точности и полноты.
Кривая точного отзыва
Из определения точности и полноты, данного в части 1, следует помнить, что чем выше точность, тем более уверенной является модель, когда она классифицирует выборку как Положительную. Чем выше отзыв, тем больше положительных образцов модель правильно классифицирует как Положительные.
Если модель имеет высокую полноту, но низкую точность, она правильно классифицирует большинство положительных образцов, но имеет много ложноположительных результатов (т. е. классифицирует многие Отрицательные образцы как Положительные). Если модель имеет высокую точность, но низкую полноту, то модель является точной, если она классифицирует образец как Положительный, но она может классифицировать только некоторые из положительных образцов.
Из-за важности как точности, так и полноты существует кривая точности-повторимости, которая показывает компромисс между значениями точности и полноты для различных пороговых значений. Эта кривая помогает выбрать лучший порог для максимизации обеих метрик.
Для создания кривой точного отзыва необходимы некоторые входные данные:
- Ярлыки базовой истины.
- Прогнозируемые оценки образцов.
- Некоторые пороговые значения для преобразования оценок прогнозов в метки классов.
Следующий блок кода создает список y_true для хранения основных меток истинности, список pred_scores для оценок прогноза и, наконец, пороги список для различных пороговых значений.
import numpy
y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative", "positive", "negative", "positive", "positive", "positive", "positive", "negative", "negative", "negative"]
pred_scores = [0.7, 0.3, 0.5, 0.6, 0.55, 0.9, 0.4, 0.2, 0.4, 0.3, 0.7, 0.5, 0.8, 0.2, 0.3, 0.35]
thresholds = numpy.arange(start=0.2, stop=0.7, step=0.05)
Вот пороговые значения, сохраненные в списке thresholds. Поскольку существует 10 порогов, будет создано 10 значений точности и полноты.
[0.2,
0.25,
0.3,
0.35,
0.4,
0.45,
0.5,
0.55,
0.6,
0.65]
Следующая функция с именем precision_recall_curve() принимает метки базовой истины, оценки прогнозов и пороговые значения. Он возвращает два списка одинаковой длины, представляющие значения точности и отзыва.
import sklearn.metrics
def precision_recall_curve(y_true, pred_scores, thresholds):
precisions = []
recalls = []
for threshold in thresholds:
y_pred = ["positive" if score >= threshold else "negative" for score in pred_scores]
precision = sklearn.metrics.precision_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
recall = sklearn.metrics.recall_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
precisions.append(precision)
recalls.append(recall)
return precisions, recalls
Следующий код вызывает функцию precision_recall_curve() после передачи трех заранее подготовленных списков. Он возвращает списки precisions и recalls, которые содержат все значения точности и отзыва соответственно.
precisions, recalls = precision_recall_curve(y_true=y_true,
pred_scores=pred_scores,
thresholds=thresholds)
Вот возвращаемые значения в списке precisions.
[0.5625,
0.5714285714285714,
0.5714285714285714,
0.6363636363636364,
0.7,
0.875,
0.875,
1.0,
1.0,
1.0]
Вот список значений в списке recalls.
[1.0,
0.8888888888888888,
0.8888888888888888,
0.7777777777777778,
0.7777777777777778,
0.7777777777777778,
0.7777777777777778,
0.6666666666666666,
0.5555555555555556,
0.4444444444444444]
Учитывая два списка одинаковой длины, можно отобразить их значения на двумерном графике, как показано ниже.
matplotlib.pyplot.plot(recalls, precisions, linewidth=4, color="red")
matplotlib.pyplot.xlabel("Recall", fontsize=12, fontweight='bold')
matplotlib.pyplot.ylabel("Precision", fontsize=12, fontweight='bold')
matplotlib.pyplot.title("Precision-Recall Curve", fontsize=15, fontweight="bold")
matplotlib.pyplot.show()
Кривая точности отзыва показана на следующем рисунке. Обратите внимание, что по мере увеличения полноты точность снижается. Причина в том, что когда количество положительных образцов увеличивается (высокая полнота), точность правильной классификации каждого образца снижается (низкая точность). Это ожидаемо, поскольку модель с большей вероятностью потерпит неудачу, если имеется много выборок.
Кривая точности и полноты позволяет легко определить точку, в которой и точность, и полнота являются высокими. Согласно предыдущему рисунку, лучшая точка — это (recall, Precision)=(0,778, 0,875).
Графическое определение наилучших значений как для точности, так и для полноты может работать с использованием предыдущего рисунка, поскольку кривая не является сложной. Лучше всего использовать метрику, называемую показателем f1, которая рассчитывается в соответствии со следующим уравнением.
Метрика f1 измеряет баланс между точностью и полнотой. Когда значение f1 велико, это означает, что и точность, и полнота высоки. Более низкий показатель f1 означает больший дисбаланс между точностью и полнотой.
Согласно предыдущему примеру, f1 рассчитывается в соответствии с приведенным ниже кодом. Согласно значениям в списке f1, наивысший балл — 0,82352941. Это шестой элемент в списке (т.е. индекс 5). Шестой элемент в списках recalls и precisions — это 0,778 и 0,875 соответственно. Соответствующее пороговое значение — 0,45.
f1 = 2 * ((numpy.array(precisions) * numpy.array(recalls)) / (numpy.array(precisions) + numpy.array(recalls)))
[0.72,
0.69565217,
0.69565217,
0.7,
0.73684211,
0.82352941,
0.82352941,
0.8,
0.71428571, 0
.61538462]
На следующем рисунке синим цветом показано расположение точки, которая соответствует наилучшему балансу между полнотой и точностью. В заключение, лучший порог для баланса точности и полноты — это 0,45, при котором точность равна 0,875, а полнота — 0,778.
matplotlib.pyplot.plot(recalls, precisions, linewidth=4, color="red", zorder=0)
matplotlib.pyplot.scatter(recalls[5], precisions[5], zorder=1, linewidth=6)
matplotlib.pyplot.xlabel("Recall", fontsize=12, fontweight='bold')
matplotlib.pyplot.ylabel("Precision", fontsize=12, fontweight='bold')
matplotlib.pyplot.title("Precision-Recall Curve", fontsize=15, fontweight="bold")
matplotlib.pyplot.show()
После обсуждения кривой точности отзыва в следующем разделе обсуждается, как рассчитать среднюю точность.
Средняя точность (AP)
Средняя точность (AP) – это способ суммировать кривую точности и полноты данных в одно значение, представляющее собой среднее значение всех погрешностей. AP рассчитывается согласно следующему уравнению. Используя цикл, который проходит через все точности/вызовы, вычисляется разница между текущим и следующим вызовами, а затем умножается на текущую точность. Другими словами, AP — это взвешенная сумма точности на каждом пороге, где вес — это увеличение отзыва.
Важно добавить к спискам отзыва и точности значения 0 и 1 соответственно. Например, если список recalls равен [0.8, 0.6], то к нему должен быть добавлен 0, чтобы получить значение [0.8, 0.6, 0.0]. То же самое происходит со списком precisions, но к нему добавляется 1, а не 0 (например, [0,8, 0,2, 1,0]).
Учитывая, что и recalls, и precisions являются массивами NumPy, предыдущее уравнение моделируется в соответствии со следующей строкой Python.
AP = numpy.sum((recalls[:-1] - recalls[1:]) * precisions[:-1])
Вот полный код, который вычисляет AP.
import numpy
import sklearn.metrics
def precision_recall_curve(y_true, pred_scores, thresholds):
precisions = []
recalls = []
for threshold in thresholds:
y_pred = ["positive" if score >= threshold else "negative" for score in pred_scores]
precision = sklearn.metrics.precision_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
recall = sklearn.metrics.recall_score(y_true=y_true, y_pred=y_pred, pos_label="positive")
precisions.append(precision)
recalls.append(recall)
return precisions, recalls
y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative", "positive", "negative", "positive", "positive", "positive", "positive", "negative", "negative", "negative"]
pred_scores = [0.7, 0.3, 0.5, 0.6, 0.55, 0.9, 0.4, 0.2, 0.4, 0.3, 0.7, 0.5, 0.8, 0.2, 0.3, 0.35]
thresholds=numpy.arange(start=0.2, stop=0.7, step=0.05)
precisions, recalls = precision_recall_curve(y_true=y_true,
pred_scores=pred_scores,
thresholds=thresholds)
precisions.append(1)
recalls.append(0)
precisions = numpy.array(precisions)
recalls = numpy.array(recalls)
AP = numpy.sum((recalls[:-1] - recalls[1:]) * precisions[:-1])
print(AP)
Это все о средней точности. Вот краткое описание шагов по расчету AP:
- Сгенерируйте оценки прогнозов с помощью модели.
- Преобразуйте оценки прогнозов в метки классов.
- Рассчитайте матрицу неточностей.
- Рассчитайте показатели точности и напоминаемости.
- Создайте кривую точности и точности.
- Измерьте среднюю точность.
В следующем разделе рассказывается о пересечении через объединение (IoU), с помощью которого обнаружение объектов генерирует оценки прогнозирования.
Пересечение через Союз (IoU)
Для обучения модели обнаружения объектов обычно имеется 2 входа:
- Изображение.
- Ограничительные рамки для каждого объекта на изображении.
Модель прогнозирует ограничивающие рамки обнаруженных объектов. Ожидается, что предсказанный блок не будет в точности соответствовать блоку базовой истины. На следующем рисунке показано изображение кошки. Поле основной истинности объекта выделено красным, а предсказанное — желтым. На основе визуализации двух полей, сделала ли модель хороший прогноз с высоким показателем соответствия?
Трудно субъективно оценить прогнозы модели. Например, кто-то может прийти к выводу, что совпадение составляет 50%, а кто-то другой заметит, что совпадение составляет 60%.
Изображение без надписей с сайта Pixabay, автор susannp4
Лучшая альтернатива — использовать количественную меру для оценки соответствия основных и предсказанных блоков. Эта мера – пересечение по объединению (IoU). IoU помогает узнать, есть ли в регионе объект или нет.
IoU рассчитывается согласно следующему уравнению путем деления площади пересечения двух блоков на площадь их объединения. Чем выше IoU, тем лучше прогноз.
На следующем рисунке показаны 3 случая с разными долговыми обязательствами. Обратите внимание, что долговые обязательства в верхней части каждого дела объективно измерены и могут немного отличаться от реальности, но это имеет смысл.
В случае A прогнозируемый желтый прямоугольник пока далек от совмещения с красным полем основной истины, поэтому оценка IoU равна 0,2 (т. е. перекрытие между двумя прямоугольниками составляет только 20%). .
В случае B область пересечения между двумя прямоугольниками больше, но эти два прямоугольника по-прежнему не выровнены должным образом, поэтому оценка IoU составляет 0,5.
В случае C координаты двух блоков настолько близки, что их IoU составляет 0,9 (т. е. перекрытие между двумя блоками составляет 90%).
Обратите внимание, что IoU равен 0,0, когда существует перекрытие 0% между прогнозируемыми и фактическими блоками. IoU равен 1,0, когда две коробки подходят друг другу на 100 %.
Чтобы вычислить IoU для изображения, существует функция с именем intersection_over_union(). Он принимает следующие 2 параметра:
gt_box: ограничивающая рамка основной истины.pred_box: прогнозируемая ограничивающая рамка.
Он вычисляет пересечение и объединение двух полей в переменных intersection и union соответственно. Более того, IoU рассчитывается в переменной iou. Он возвращает все эти 3 переменные.
def intersection_over_union(gt_box, pred_box):
inter_box_top_left = [max(gt_box[0], pred_box[0]), max(gt_box[1], pred_box[1])]
inter_box_bottom_right = [min(gt_box[0]+gt_box[2], pred_box[0]+pred_box[2]), min(gt_box[1]+gt_box[3], pred_box[1]+pred_box[3])]
inter_box_w = inter_box_bottom_right[0] - inter_box_top_left[0]
inter_box_h = inter_box_bottom_right[1] - inter_box_top_left[1]
intersection = inter_box_w * inter_box_h
union = gt_box[2] * gt_box[3] + pred_box[2] * pred_box[3] - intersection
iou = intersection / union
return iou, intersection, union
Ограничивающая рамка, передаваемая функции, представляет собой список из 4 элементов:
- Ось X верхнего левого угла.
- Ось Y верхнего левого угла.
- Ширина.
- Высота.
Вот основные и предсказанные ограничивающие рамки изображения автомобиля.
gt_box = [320, 220, 680, 900]
pred_box = [500, 320, 550, 700]
Учитывая, что изображение называется cat.jpg, вот комплект, который рисует ограничивающие рамки поверх изображения.
import imageio
import matplotlib.pyplot
import matplotlib.patches
def intersection_over_union(gt_box, pred_box):
inter_box_top_left = [max(gt_box[0], pred_box[0]), max(gt_box[1], pred_box[1])]
inter_box_bottom_right = [min(gt_box[0]+gt_box[2], pred_box[0]+pred_box[2]), min(gt_box[1]+gt_box[3], pred_box[1]+pred_box[3])]
inter_box_w = inter_box_bottom_right[0] - inter_box_top_left[0]
inter_box_h = inter_box_bottom_right[1] - inter_box_top_left[1]
intersection = inter_box_w * inter_box_h
union = gt_box[2] * gt_box[3] + pred_box[2] * pred_box[3] - intersection
iou = intersection / union
return iou, intersection, union
im = imageio.imread("cat.jpg")
gt_box = [320, 220, 680, 900]
pred_box = [500, 320, 550, 700]
fig, ax = matplotlib.pyplot.subplots(1)
ax.imshow(im)
gt_rect = matplotlib.patches.Rectangle((gt_box[0], gt_box[1]),
gt_box[2],
gt_box[3],
linewidth=5,
edgecolor='r',
facecolor='none')
pred_rect = matplotlib.patches.Rectangle((pred_box[0], pred_box[1]),
pred_box[2],
pred_box[3],
linewidth=5,
edgecolor=(1, 1, 0),
facecolor='none')
ax.add_patch(gt_rect)
ax.add_patch(pred_rect)
ax.axes.get_xaxis().set_ticks([])
ax.axes.get_yaxis().set_ticks([])
На следующем рисунке показано изображение с ограничивающими рамками.
Чтобы вычислить IoU, просто вызовите функцию intersection_over_union(). Судя по ограничивающим рамкам, оценка IoU составляет 0,54.
iou, intersect, union = intersection_over_union(gt_box, pred_box)
print(iou, intersect, union)
0.5409582689335394 350000 647000
Оценка IoU 0,54 означает, что между основной истиной и прогнозируемыми ограничивающими рамками перекрытие составляет 54 %. Глядя на коробки, кто-то может визуально почувствовать, что этого достаточно, чтобы сделать вывод, что модель обнаружила объект-кошку. Кто-то другой может посчитать, что модель еще не точна, поскольку предсказанная рамка плохо соответствует основной истине.
Чтобы объективно судить, правильно ли модель предсказала расположение ящика, используется порог. Если модель прогнозирует блок с показателем IoU, превышающим или равным порогу, то между прогнозируемым блоком и одним из основных блоков истинности имеется сильное перекрытие. Это означает, что модель смогла успешно обнаружить объект. Обнаруженная область классифицируется как Положительная (т. е. содержит объект).
С другой стороны, когда оценка IoU меньше порогового значения, модель дает неверный прогноз, поскольку прогнозируемый блок не перекрывается с блоком основной истины. Это означает, что обнаруженная область классифицируется как Негативная (т. е. не содержит объекта).
Давайте приведем пример, чтобы прояснить, как оценки IoU помогают классифицировать регион как объект или нет. Предположим, что в модель обнаружения объектов подается следующее изображение, где есть два целевых объекта с полями основной истины красного цвета, а прямоугольники прогнозов — желтыми.
Следующий код считывает изображение (если оно называется pets.jpg), рисует прямоугольники и вычисляет IoU для каждого объекта. IoU для левого объекта составляет 0,76, тогда как показатель IoU для другого объекта составляет 0,26.
import matplotlib.pyplot
import matplotlib.patches
import imageio
def intersection_over_union(gt_box, pred_box):
inter_box_top_left = [max(gt_box[0], pred_box[0]), max(gt_box[1], pred_box[1])]
inter_box_bottom_right = [min(gt_box[0]+gt_box[2], pred_box[0]+pred_box[2]), min(gt_box[1]+gt_box[3], pred_box[1]+pred_box[3])]
inter_box_w = inter_box_bottom_right[0] - inter_box_top_left[0]
inter_box_h = inter_box_bottom_right[1] - inter_box_top_left[1]
intersection = inter_box_w * inter_box_h
union = gt_box[2] * gt_box[3] + pred_box[2] * pred_box[3] - intersection
iou = intersection / union
return iou, intersection, union,
im = imageio.imread("pets.jpg")
gt_box = [10, 130, 370, 350]
pred_box = [30, 100, 370, 350]
iou, intersect, union = intersection_over_union(gt_box, pred_box)
print(iou, intersect, union)
fig, ax = matplotlib.pyplot.subplots(1)
ax.imshow(im)
gt_rect = matplotlib.patches.Rectangle((gt_box[0], gt_box[1]),
gt_box[2],
gt_box[3],
linewidth=5,
edgecolor='r',
facecolor='none')
pred_rect = matplotlib.patches.Rectangle((pred_box[0], pred_box[1]),
pred_box[2],
pred_box[3],
linewidth=5,
edgecolor=(1, 1, 0),
facecolor='none')
ax.add_patch(gt_rect)
ax.add_patch(pred_rect)
gt_box = [645, 130, 310, 320]
pred_box = [500, 60, 310, 320]
iou, intersect, union = intersection_over_union(gt_box, pred_box)
print(iou, intersect, union)
gt_rect = matplotlib.patches.Rectangle((gt_box[0], gt_box[1]),
gt_box[2],
gt_box[3],
linewidth=5,
edgecolor='r',
facecolor='none')
pred_rect = matplotlib.patches.Rectangle((pred_box[0], pred_box[1]),
pred_box[2],
pred_box[3],
linewidth=5,
edgecolor=(1, 1, 0),
facecolor='none')
ax.add_patch(gt_rect)
ax.add_patch(pred_rect)
ax.axes.get_xaxis().set_ticks([])
ax.axes.get_yaxis().set_ticks([])
Учитывая, что порог IoU равен 0,6, только регионы с показателем IoU больше или равным 0,6 классифицируются как Положительные (т. е. имеющие объекты). Таким образом, блок с показателем IoU 0,76 является положительным, а другой блок с показателем IoU 0,26 — отрицательным.
Изображение без надписей с сайта Hindustantimes.com
Если пороговое значение изменилось на 0,2, а не на 0,6, то оба прогноза являются положительными. Если пороговое значение равно 0,8, то оба прогноза являются отрицательными.
Подводя итог, можно сказать, что оценка IoU показывает, насколько близок прогнозируемый блок к блоку базовой истины. Он варьируется от 0,0 до 1,0, где 1,0 — оптимальный результат. Когда IoU превышает пороговое значение, блок классифицируется как Положительный, поскольку он окружает объект. В противном случае оно классифицируется как Негативное.
В следующем разделе показано, как извлечь выгоду из IoUs для расчета средней средней точности (mAP) для модели обнаружения объектов.
Средняя средняя точность (mAP) обнаружения объектов
Обычно модели обнаружения объектов оцениваются с разными порогами IoU, где каждый порог может давать прогнозы, отличные от других порогов. Предположим, что в модель подается изображение, содержащее 10 объектов, распределенных по 2 классам. Как рассчитать МАП?
Чтобы рассчитать mAP, начните с расчета AP для каждого класса. Среднее значение AP для всех классов — это mAP.
Предполагается, что используемый набор данных содержит только 2 класса. Для первого класса здесь приведены метки основной истины и прогнозируемые оценки в переменных y_true и pred_scores соответственно.
y_true = ["positive", "negative", "positive", "negative", "positive", "positive", "positive", "negative", "positive", "negative"]
pred_scores = [0.7, 0.3, 0.5, 0.6, 0.55, 0.9, 0.75, 0.2, 0.8, 0.3]
Вот переменные y_true и pred_scores второго класса.
y_true = ["negative", "positive", "positive", "negative", "negative", "positive", "positive", "positive", "negative", "positive"]
pred_scores = [0.32, 0.9, 0.5, 0.1, 0.25, 0.9, 0.55, 0.3, 0.35, 0.85]
Список порогов IoU начинается от 0,2 до 0,9 с шагом 0,25.
thresholds = numpy.arange(start=0.2, stop=0.9, step=0.05)
Чтобы вычислить AP для класса, просто передайте его переменные y_true и pred_scores в следующий код.
precisions, recalls = precision_recall_curve(y_true=y_true,
pred_scores=pred_scores,
thresholds=thresholds)
matplotlib.pyplot.plot(recalls, precisions, linewidth=4, color="red", zorder=0)
matplotlib.pyplot.xlabel("Recall", fontsize=12, fontweight='bold')
matplotlib.pyplot.ylabel("Precision", fontsize=12, fontweight='bold')
matplotlib.pyplot.title("Precision-Recall Curve", fontsize=15, fontweight="bold")
matplotlib.pyplot.show()
precisions.append(1)
recalls.append(0)
precisions = numpy.array(precisions)
recalls = numpy.array(recalls)
AP = numpy.sum((recalls[:-1] - recalls[1:]) * precisions[:-1])
print(AP)
Для первого класса вот кривая точности отзыва. Судя по этой кривой, AP составляет 0,949.
Кривая точности отзыва второго класса показана ниже. Его AP составляет 0,958.
На основе AP двух классов (0,949 и 0,958) mAP модели обнаружения объектов рассчитывается по следующему уравнению.
Согласно этому уравнению, mAP составляет 0,9535.
mAP = (0.949 + 0.958)/2 = 0.9535
Заключение
В этом руководстве обсуждается, как рассчитать среднюю точность (mAP) для модели обнаружения объектов. Мы начали с обсуждения того, как преобразовать оценку прогноза в метку класса. Используя различные пороговые значения, создается кривая точности отзыва. По этой кривой измеряется средняя точность (AP).
Для модели обнаружения объектов порогом является пересечение через объединение (IoU), которое оценивает обнаруженные объекты. После измерения AP для каждого класса в наборе данных рассчитывается mAP.