Матрица ошибок true positive

На чтение 3 мин. Опубликовано 13.06.2019

В компьютерном зрении обнаружение объекта — это проблема определения местоположения одного или нескольких объектов на изображении. Помимо традиционных методов обнаружения, продвинутые модели глубокого обучения, такие как R-CNN и YOLO, могут обеспечить впечатляющие результаты при различных типах объектов. Эти модели принимают изображение в качестве входных данных и возвращают координаты прямоугольника, ограничивающего пространство вокруг каждого найденного объекта.

В этом руководстве обсуждается матрица ошибок и то, как рассчитываются precision, recall и accuracy метрики.

Здесь мы рассмотрим:

• Матрицу ошибок для двоичной классификации.
• Матрицу ошибок для мультиклассовой классификации.
• Расчет матрицы ошибок с помощью Scikit-learn.
• Accuracy, Precision и Recall.
• Precision или Recall?

Матрица ошибок для бинарной классификации

В бинарной классификации каждая выборка относится к одному из двух классов. Обычно им присваиваются такие метки, как 1 и 0, или положительный и отрицательный (Positive и Negative). Также могут использоваться более конкретные обозначения для классов: злокачественный или доброкачественный (например, если проблема связана с классификацией рака), успех или неудача (если речь идет о классификации результатов тестов учащихся).

Предположим, что существует проблема бинарной классификации с классами positive и negative. Вот пример достоверных или эталонных меток для семи выборок, используемых для обучения модели.

positive, negative, negative, positive, positive, positive, negative

Такие наименования нужны в первую очередь для того, чтобы нам, людям, было проще различать классы. Для модели более важна числовая оценка. Обычно при передаче очередного набора данных на выходе вы получите не метку класса, а числовой результат. Например, когда эти семь семплов вводятся в модель, каждому классу будут назначены следующие значения:

0.6, 0.2, 0.55, 0.9, 0.4, 0.8, 0.5

На основании полученных оценок каждой выборке присваивается соответствующий класс. Такое преобразование числовых результатов в метки происходит с помощью порогового значения. Данное граничное условие является гиперпараметром модели и может быть определено пользователем. Например, если порог равен 0.5, тогда любая оценка, которая больше или равна 0.5, получает положительную метку. В противном случае — отрицательную. Вот предсказанные алгоритмом классы:

positive (0.6), negative (0.2), positive (0.55), positive (0.9), negative (0.4), positive (0.8), positive (0.5)

Сравните достоверные и полученные метки — мы имеем 4 верных и 3 неверных предсказания. Стоит добавить, что изменение граничного условия отражается на результатах. Например, установка порога, равного 0.6, оставляет только два неверных прогноза.

Реальность: positive, negative, negative, positive, positive, positive, negative 
Предсказания: positive, negative, positive, positive, negative, positive, positive

Для получения дополнительной информации о характеристиках модели используется матрица ошибок (confusion matrix). Матрица ошибок помогает нам визуализировать, «ошиблась» ли модель при различении двух классов. Как видно на следующем рисунке, это матрица 2х2. Названия строк представляют собой эталонные метки, а названия столбцов — предсказанные.

Четыре элемента матрицы (клетки красного и зеленого цвета) представляют собой четыре метрики, которые подсчитывают количество правильных и неправильных прогнозов, сделанных моделью. Каждому элементу дается метка, состоящая из двух слов:

1. True или False.
2. Positive или Negative.

True, если получено верное предсказание, то есть эталонные и предсказанные метки классов совпадают, и False, когда они не совпадают. Positive или Negative — названия предсказанных меток.

Таким образом, всякий раз, когда прогноз неверен, первое слово в ячейке False, когда верен — True. Наша цель состоит в том, чтобы максимизировать показатели со словом «True» (True Positive и True Negative) и минимизировать два других (False Positive и False Negative). Четыре метрики в матрице ошибок представляют собой следующее:

1. Верхний левый элемент (True Positive): сколько раз модель правильно классифицировала Positive как Positive?
2. Верхний правый (False Negative): сколько раз модель неправильно классифицировала Positive как Negative?
3. Нижний левый (False Positive): сколько раз модель неправильно классифицировала Negative как Positive?
4. Нижний правый (True Negative): сколько раз модель правильно классифицировала Negative как Negative?

Мы можем рассчитать эти четыре показателя для семи предсказаний, использованных нами ранее. Полученная матрица ошибок представлена на следующем рисунке.

Вот так вычисляется матрица ошибок для задачи двоичной классификации. Теперь посмотрим, как решить данную проблему для большего числа классов.

Матрица ошибок для мультиклассовой классификации

Что, если у нас более двух классов? Как вычислить эти четыре метрики в матрице ошибок для задачи мультиклассовой классификации? Очень просто!

Предположим, имеется 9 семплов, каждый из которых относится к одному из трех классов: White, Black или Red. Вот достоверные метки для 9 выборок:

Red, Black, Red, White, White, Red, Black, Red, White

После загрузки данных модель делает следующее предсказание:

Red, White, Black, White, Red, Red, Black, White, Red

Для удобства сравнения здесь они расположены рядом.

Реальность: Red, Black, Red, White, White, Red, Black, Red, White Предсказания: Red, White, Black, White, Red, Red, Black, White, Red

Перед вычислением матрицы ошибок необходимо выбрать целевой класс. Давайте назначим на эту роль класс Red. Он будет отмечен как Positive, а все остальные отмечены как Negative.

Positive, Negative, Positive, Negative, Negative, Positive, Negative, Positive, Negative Positive, Negative, Negative, Negative, Positive, Positive, Negative, Negative, Positive

11111111111111111111111После замены остались только два класса (Positive и Negative), что позволяет нам рассчитать матрицу ошибок, как было показано в предыдущем разделе. Стоит заметить, что полученная матрица предназначена только для класса Red.

Далее для класса White заменим каждое его вхождение на Positive, а метки всех остальных классов на Negative. Мы получим такие достоверные и предсказанные метки:

Negative, Negative, Negative, Positive, Positive, Negative, Negative, Negative, Positive Negative, Positive, Negative, Positive, Negative, Negative, Negative, Positive, Negative

На следующей схеме показана матрица ошибок для класса White.

Точно так же может быть получена матрица ошибок для Black.

Расчет матрицы ошибок с помощью Scikit-Learn

В популярной Python-библиотеке Scikit-learn есть модуль metrics, который можно использовать для вычисления метрик в матрице ошибок.

Для задач с двумя классами используется функция confusion_matrix(). Мы передадим в функцию следующие параметры:

1. y_true: эталонные метки.
2. y_pred: предсказанные метки.

Следующий код вычисляет матрицу ошибок для примера двоичной классификации, который мы обсуждали ранее.

import sklearn.metrics

y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative"]
y_pred = ["positive", "negative", "positive", "positive", "negative", "positive", "positive"]

r = sklearn.metrics.confusion_matrix(y_true, y_pred)
print(r)

 

array([[1, 2],
       [1, 3]], dtype=int64)

Обратите внимание, что порядок метрик отличается от описанного выше. Например, показатель True Positive находится в правом нижнем углу, а True Negative — в верхнем левом углу. Чтобы исправить это, мы можем перевернуть матрицу.

import numpy

r = numpy.flip(r)
print(r)

 

array([[3, 1],
       [2, 1]], dtype=int64)

Чтобы вычислить матрицу ошибок для задачи с большим числом классов, используется функция multilabel_confusion_matrix(), как показано ниже. В дополнение к параметрам y_true и y_pred третий параметр labels принимает список классовых меток.

import sklearn.metrics
import numpy

y_true = ["Red", "Black", "Red",   "White", "White", "Red", "Black", "Red",   "White"]
y_pred = ["Red", "White", "Black", "White", "Red",   "Red", "Black", "White", "Red"]

r = sklearn.metrics.multilabel_confusion_matrix(y_true, y_pred, labels=["White", "Black", "Red"])
print(r)

 

array([
    [[4 2]
     [2 1]]

    [[6 1]
     [1 1]]
    
    [[3 2]
     [2 2]]], dtype=int64)

Функция вычисляет матрицу ошибок для каждого класса и возвращает все матрицы. Их порядок соответствует порядку меток в параметре labels. Чтобы изменить последовательность метрик в матрицах, мы будем снова использовать функцию numpy.flip().

print(numpy.flip(r[0]))  # матрица ошибок для класса White
print(numpy.flip(r[1]))  # матрица ошибок для класса Black
print(numpy.flip(r[2]))  # матрица ошибок для класса Red

 

# матрица ошибок для класса White
[[1 2]
 [2 4]]

# матрица ошибок для класса Black
[[1 1]
 [1 6]]

# матрица ошибок для класса Red
[[2 2]
 [2 3]]

В оставшейся части этого текста мы сосредоточимся только на двух классах. В следующем разделе обсуждаются три ключевых показателя, которые рассчитываются на основе матрицы ошибок.

Как мы уже видели, матрица ошибок предлагает четыре индивидуальных показателя. На их основе можно рассчитать другие метрики, которые предоставляют дополнительную информацию о поведении модели:

1. Accuracy
2. Precision
3. Recall

В следующих подразделах обсуждается каждый из этих трех показателей.

Метрика Accuracy

Accuracy — это показатель, который описывает общую точность предсказания модели по всем классам. Это особенно полезно, когда каждый класс одинаково важен. Он рассчитывается как отношение количества правильных прогнозов к их общему количеству.

Рассчитаем accuracy с помощью Scikit-learn на основе ранее полученной матрицы ошибок. Переменная acc содержит результат деления суммы True Positive и True Negative метрик на сумму всех значений матрицы. Таким образом, accuracy, равная 0.5714, означает, что модель с точностью 57,14% делает верный прогноз.

import numpy
import sklearn.metrics

y_true = ["positive", "negative", "negative", "positive", "positive", "positive", "negative"]
y_pred = ["positive", "negative", "positive", "positive", "negative", "positive", "positive"]

r = sklearn.metrics.confusion_matrix(y_true, y_pred)
r = numpy.flip(r)

acc = (r[0][0] + r[-1][-1]) / numpy.sum(r)
print(acc)
# вывод будет 0.571

 

В модуле sklearn.metrics есть функция precision_score(), которая также может вычислять accuracy. Она принимает в качестве аргументов достоверные и предсказанные метки.

acc = sklearn.metrics.accuracy_score(y_true, y_pred)

 

Стоит учесть, что метрика accuracy может быть обманчивой. Один из таких случаев — это несбалансированные данные. Предположим, у нас есть всего 600 единиц данных, из которых 550 относятся к классу Positive и только 50 — к Negative. Поскольку большинство семплов принадлежит к одному классу, accuracy для этого класса будет выше, чем для другого.

Если модель сделала 530 правильных прогнозов из 550 для класса Positive, по сравнению с 5 из 50 для Negative, то общая accuracy равна (530 + 5) / 600 = 0.8917. Это означает, что точность модели составляет 89.17%. Полагаясь на это значение, вы можете подумать, что для любой выборки (независимо от ее класса) модель сделает правильный прогноз в 89.17% случаев. Это неверно, так как для класса Negative модель работает очень плохо.

Precision

Precision представляет собой отношение числа семплов, верно классифицированных как Positive, к общему числу выборок с меткой Positive (распознанных правильно и неправильно). Precision измеряет точность модели при определении класса Positive.

Когда модель делает много неверных Positive классификаций, это увеличивает знаменатель и снижает precision. С другой стороны, precision высока, когда:

1. Модель делает много корректных предсказаний класса Positive (максимизирует True Positive метрику).
2. Модель делает меньше неверных Positive классификаций (минимизирует False Positive).

Представьте себе человека, который пользуется всеобщим доверием; когда он что-то предсказывает, окружающие ему верят. Метрика precision похожа на такого персонажа. Если она высока, вы можете доверять решению модели по определению очередной выборки как Positive. Таким образом, precision помогает узнать, насколько точна модель, когда она говорит, что семпл имеет класс Positive.

Основываясь на предыдущем обсуждении, вот определение precision:

Precision отражает, насколько надежна модель при классификации Positive-меток.

На следующем изображении зеленая метка означает, что зеленый семпл классифицирован как Positive, а красный крест – как Negative. Модель корректно распознала две Positive выборки, но неверно классифицировала один Negative семпл как Positive. Из этого следует, что метрика True Positive равна 2, когда False Positive имеет значение 1, а precision составляет 2 / (2 + 1) = 0.667. Другими словами, процент доверия к решению модели, что выборка относится к классу Positive, составляет 66.7%.

Цель precision – классифицировать все Positive семплы как Positive, не допуская ложных определений Negative как Positive. Согласно следующему рисунку, если все три Positive выборки предсказаны правильно, но один Negative семпл классифицирован неверно, precision составляет 3 / (3 + 1) = 0.75. Таким образом, утверждения модели о том, что выборка относится к классу Positive, корректны с точностью 75%.

Единственный способ получить 100% precision — это классифицировать все Positive выборки как Positive без классификации Negative как Positive.

В Scikit-learn модуль sklearn.metrics имеет функцию precision_score(), которая получает в качестве аргументов эталонные и предсказанные метки и возвращает precision. Параметр pos_label принимает метку класса Positive (по умолчанию 1).

import sklearn.metrics

y_true = ["positive", "positive", "positive", "negative", "negative", "negative"]
y_pred = ["positive", "positive", "negative", "positive", "negative", "negative"]

precision = sklearn.metrics.precision_score(y_true, y_pred, pos_label="positive")
print(precision)

 

Вывод: 0.6666666666666666.

Recall

Recall рассчитывается как отношение числа Positive выборок, корректно классифицированных как Positive, к общему количеству Positive семплов. Recall измеряет способность модели обнаруживать выборки, относящиеся к классу Positive. Чем выше recall, тем больше Positive семплов было найдено.

Recall заботится только о том, как классифицируются Positive выборки. Эта метрика не зависит от того, как предсказываются Negative семплы, в отличие от precision. Когда модель верно классифицирует все Positive выборки, recall будет 100%, даже если все представители класса Negative были ошибочно определены как Positive. Давайте посмотрим на несколько примеров.

На следующем изображении представлены 4 разных случая (от A до D), и все они имеют одинаковый recall, равный 0.667. Представленные примеры отличаются только тем, как классифицируются Negative семплы. Например, в случае A все Negative выборки корректно определены, а в случае D – наоборот. Независимо от того, как модель предсказывает класс Negative, recall касается только семплов относящихся к Positive.

Из 4 случаев, показанных выше, только 2 Positive выборки определены верно. Таким образом, метрика True Positive равна 2. False Negative имеет значение 1, потому что только один Positive семпл классифицируется как Negative. В результате recall будет равен 2 / (2 + 1) = 2/3 = 0.667.
Поскольку не имеет значения, как предсказываются объекты класса Negative, лучше их просто игнорировать, как показано на следующей схеме. При расчете recall необходимо учитывать только Positive выборки.

Что означает, когда recall высокий или низкий? Если recall имеет большое значение, все Positive семплы классифицируются верно. Следовательно, модели можно доверять в ее способности обнаруживать представителей класса Positive.

На следующем изображении recall равен 1.0, потому что все Positive семплы были правильно классифицированы. Показатель True Positive равен 3, а False Negative – 0. Таким образом, recall вычисляется как 3 / (3 + 0) = 1. Это означает, что модель обнаружила все Positive выборки. Поскольку recall не учитывает, как предсказываются представители класса Negative, могут присутствовать множество неверно определенных Negative семплов (высокая False Positive метрика).

С другой стороны, recall равен 0.0, если не удается обнаружить ни одной Positive выборки. Это означает, что модель обнаружила 0% представителей класса Positive. Показатель True Positive равен 0, а False Negative имеет значение 3. Recall будет равен 0 / (0 + 3) = 0.

Когда recall имеет значение от 0.0 до 1.0, это число отражает процент Positive семплов, которые модель верно классифицировала. Например, если имеется 10 экземпляров Positive и recall равен 0.6, получается, что модель корректно определила 60% объектов класса Positive (т.е. 0.6 * 10 = 6).

Подобно precision_score(), функция repl_score() из модуля sklearn.metrics вычисляет recall. В следующем блоке кода показан пример ее использования.

import sklearn.metrics

y_true = ["positive", "positive", "positive", "negative", "negative", "negative"]
y_pred = ["positive", "positive", "negative", "positive", "negative", "negative"]

recall = sklearn.metrics.recall_score(y_true, y_pred, pos_label="positive")
print(recall)

 

Вывод: 0.6666666666666666.

После определения precision и recall давайте кратко подведем итоги:

• Precision измеряет надежность модели при классификации Positive семплов, а recall определяет, сколько Positive выборок было корректно предсказано моделью.
• Precision учитывает классификацию как Positive, так и Negative семплов. Recall же использует при расчете только представителей класса Positive. Другими словами, precision зависит как от Negative, так и от Positive-выборок, но recall — только от Positive.
• Precision принимает во внимание, когда семпл определяется как Positive, но не заботится о верной классификации всех объектов класса Positive. Recall в свою очередь учитывает корректность предсказания всех Positive выборок, но не заботится об ошибочной классификации представителей Negative как Positive.
• Когда модель имеет высокий уровень recall метрики, но низкую precision, такая модель правильно определяет большинство Positive семплов, но имеет много ложных срабатываний (классификаций Negative выборок как Positive). Если модель имеет большую precision, но низкий recall, то она делает высокоточные предсказания, определяя класс Positive, но производит всего несколько таких прогнозов.

Некоторые вопросы для проверки понимания:

• Если recall равен 1.0, а в датасете имеются 5 объектов класса Positive, сколько Positive семплов было правильно классифицировано моделью?
• Учитывая, что recall составляет 0.3, когда в наборе данных 30 Positive семплов, сколько представителей класса Positive будет предсказано верно?
• Если recall равен 0.0 и в датасете14 Positive-семплов, сколько корректных предсказаний класса Positive было сделано моделью?

Precision или Recall?

Решение о том, следует ли использовать precision или recall, зависит от типа вашей проблемы. Если цель состоит в том, чтобы обнаружить все positive выборки (не заботясь о том, будут ли negative семплы классифицированы как positive), используйте recall. Используйте precision, если ваша задача связана с комплексным предсказанием класса Positive, то есть учитывая Negative семплы, которые были ошибочно классифицированы как Positive.

Представьте, что вам дали изображение и попросили определить все автомобили внутри него. Какой показатель вы используете? Поскольку цель состоит в том, чтобы обнаружить все автомобили, используйте recall. Такой подход может ошибочно классифицировать некоторые объекты как целевые, но в конечном итоге сработает для предсказания всех автомобилей.

Теперь предположим, что вам дали снимок с результатами маммографии, и вас попросили определить наличие рака. Какой показатель вы используете? Поскольку он обязан быть чувствителен к неверной идентификации изображения как злокачественного, мы должны быть уверены, когда классифицируем снимок как Positive (то есть с раком). Таким образом, предпочтительным показателем в данном случае является precision.

Вывод

В этом руководстве обсуждалась матрица ошибок, вычисление ее 4 метрик (true/false positive/negative) для задач бинарной и мультиклассовой классификации. Используя модуль metrics библиотеки Scikit-learn, мы увидели, как получить матрицу ошибок в Python.

Основываясь на этих 4 показателях, мы перешли к обсуждению accuracy, precision и recall метрик. Каждая из них была определена и использована в нескольких примерах. Модуль sklearn.metrics применяется для расчета каждого вышеперечисленного показателя.

• Главная
• Вопросы и ответы

Матрица ошибок и расчет показателей точности тематических карт

Дано определение матрицы ошибок (confusion matrix, contingency table, error matrix), приведены примеры использования.

Обсудить в форуме Комментариев — 2

Матрица ошибок представляет собой инструмент, использующий кросс-табуляцию (http://en.wikipedia.org/wiki/Cross-tabulation) для показа того, как соотносятся значения совпадающих классов, полученные из различных источников. В качестве источников могут выступать, например, проверяемый растр (тематическая классификация) и опорный более точный источник данных (растр или набор полевых данных в виде точек). При интерпретации результатов обычно полагается, что проверяемый результат потенциально является неточным, а проверочный растр хорошо отражает реальную ситуацию. В противном случае, если проверочный растр также несовершенен, нельзя говорить об «ошибке», а следует говорить о «разнице» между двумя наборами данных. Для построения матрицы могут использоваться все ячейки растра (пиксели) или выборка ячеек, расположенных случайно, стратифицировано случайно или согласно какому-либо другому распределению.

По одной из осей матрицы записываются названия классов легенды классификации проверяемого набора данных, по второй — классы легенды данных, используемых для проверки.

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

Для определения точности определенного расчетного класса, необходимо разделить количество правильно классифицированных пикселей этого класса на общее количество пикселей в этом классе согласно проверочным данным. Этот показатель также называют «точностью производителя» (producer’s accuracy), так как он показывает, насколько хорошо результат классификации для этого класса совпадает с проверочными данными. Для класса A:

Похожий показатель может быть вычислен для реального класса, если разделить количество правильно классифицированных пикселей класса на общее количество пикселей в этом классе согласно проверяемым данным. Этот показатель называют «точностью пользователя» (user’s accuracy), так как он показывает пользователю классификации насколько вероятно, что данный класс совпадает с результатами классификации. Для класса A:

Вне-диагональные элементы показывает случаи несовпадения между расчетными и реальными классами (ошибки классификации).

Пример 1 Маска пожаров

Приведем пример реальной ситуации, при желании вы можете повторить все расчеты и вычисления. Допустим, у нас есть классификации, показывающие какая территория сгорела, а какая нет. Одна из этих классификаций сделана на базе данных AVHRR, а другая — MODIS. Например, иллюстрация показывает результат наложения двух классификаций, где:

В этом случае, если мы обозначим сгоревшую территорию как «ДА», а не сгоревшую как «НЕТ», наша матрица ошибок будет выглядеть следующим образом:

Рассчитаем общую ошибку и ошибки для разных классов.

Общая точность 83%, из рисунка очевидно, что решающую роль в такой высокой точности играет масса территорий, классифицированных как несгоревшие обоими источниками.

Точность производителя (producer’s accuracy) для класса сгоревших территорий – 88%. Высокая точность производителя означает, что в проверяемой классификации мало ошибок омиссии (ommission errors), т.е. мало сгоревших пикселей было пропущено. Другими словами, небольшое количество пикселей, которые были на самом деле (согласно проверочному набору) сгоревшими, были ошибочно классифицированы как несгоревшие.

Точность пользователя (user’s accuracy) для класса сгоревших территорий – 54%. Низкая точность пользователя означает, что в проверяемой классификации много ошибок комиссии (commission errors), т.е. много пикселей, которые не сгорели, но были классифицированы как сгоревшие.

Разберем интерпретацию точностей для класса сгоревших территорий, как целевого класса в данном примере. Как можно видеть, для этого класса точность производителя значительно лучше точности пользователя, что в переводе на человеческий язык означает, что при производстве данного набора данных предпочтение было отдано тому, что «лучше, чтобы все территории которые на самом деле сгорели, были классифицированы как сгоревшие», а не «лучше, чтобы сгоревших территорий было меньше, но все они были точно сгоревшими».

Как видно из примера, ошибки комиссии и омиссии для одного класса часто являются противоположными, высокое значение одной из них часто связано с низким значением другой. Интерпретация качества классификации зависит от ставящихся перед ней задач, обычной стратегией является нахождение максимального значения обоих типов ошибок.

Пример 2

Более сложный пример, с большим количеством классов (источник):

Количество классов q = 5.

Рассчитаем общую точность, точность производителя и пользователя:

Расчеты всех показателей точности для приведенных выше данных в формате MS Excel XLS.

Обсудить в форуме Комментариев — 2

Последнее обновление: September 09 2021

Дата создания: 06.01.2010

Автор(ы): Денис Рыков

В машинном обучении различают оценки качества для задачи классификации и регрессии. Причем оценка задачи классификации часто значительно сложнее, чем оценка регрессии.

Оценки качества классификации

Матрица ошибок (англ. Сonfusion matrix)

Перед переходом к самим метрикам необходимо ввести важную концепцию для описания этих метрик в терминах ошибок классификации — confusion matrix (матрица ошибок).
Допустим, что у нас есть два класса и алгоритм, предсказывающий принадлежность каждого объекта одному из классов.
Рассмотрим пример. Пусть банк использует систему классификации заёмщиков на кредитоспособных и некредитоспособных. При этом первым кредит выдаётся, а вторые получат отказ. Таким образом, обнаружение некредитоспособного заёмщика () можно рассматривать как «сигнал тревоги», сообщающий о возможных рисках.

Любой реальный классификатор совершает ошибки. В нашем случае таких ошибок может быть две:

• Кредитоспособный заёмщик распознается моделью как некредитоспособный и ему отказывается в кредите. Данный случай можно трактовать как «ложную тревогу».
• Некредитоспособный заёмщик распознаётся как кредитоспособный и ему ошибочно выдаётся кредит. Данный случай можно рассматривать как «пропуск цели».

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

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

• Некредитоспособный заёмщик классифицирован как некредитоспособный, т.е. положительный класс распознан как положительный. Наблюдения, для которых это имеет место называются истинно-положительными (True Positive — TP).
• Кредитоспособный заёмщик классифицирован как кредитоспособный, т.е. отрицательный класс распознан как отрицательный. Наблюдения, которых это имеет место, называются истинно отрицательными (True Negative — TN).
• Кредитоспособный заёмщик классифицирован как некредитоспособный, т.е. имела место ошибка, в результате которой отрицательный класс был распознан как положительный. Наблюдения, для которых был получен такой исход классификации, называются ложно-положительными (False Positive — FP), а ошибка классификации называется ошибкой I рода.
• Некредитоспособный заёмщик распознан как кредитоспособный, т.е. имела место ошибка, в результате которой положительный класс был распознан как отрицательный. Наблюдения, для которых был получен такой исход классификации, называются ложно-отрицательными (False Negative — FN), а ошибка классификации называется ошибкой II рода.

Таким образом, ошибка I рода, или ложно-положительный исход классификации, имеет место, когда отрицательное наблюдение распознано моделью как положительное. Ошибкой II рода, или ложно-отрицательным исходом классификации, называют случай, когда положительное наблюдение распознано как отрицательное. Поясним это с помощью матрицы ошибок классификации:

	Истинно-положительный (True Positive — TP)	Ложно-положительный (False Positive — FP)
	Ложно-отрицательный (False Negative — FN)	Истинно-отрицательный (True Negative — TN)

Здесь — это ответ алгоритма на объекте, а — истинная метка класса на этом объекте.
Таким образом, ошибки классификации бывают двух видов: False Negative (FN) и False Positive (FP).
P означает что классификатор определяет класс объекта как положительный (N — отрицательный). T значит что класс предсказан правильно (соответственно F — неправильно). Каждая строка в матрице ошибок представляет спрогнозированный класс, а каждый столбец — фактический класс.

 # код для матрицы ошибок
 # Пример классификатора, способного проводить различие между всего лишь двумя
 # классами, "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.metrics import confusion_matrix
 from sklearn.linear_model import SGDClassifier
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (англ. Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распозновать пятерки на целом обучающем наборе
 # Для расчета матрицы ошибок сначала понадобится иметь набор прогнозов, чтобы их можно было сравнивать с фактическими целями
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 print(confusion_matrix(y_train_5, y_train_pred))
 # array([[53892, 687],
 #        [ 1891, 3530]])

Безупречный классификатор имел бы только истинно-поло­жительные и истинно отрицательные классификации, так что его матрица ошибок содержала бы ненулевые значения только на своей главной диа­гонали (от левого верхнего до правого нижнего угла):

 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.metrics import confusion_matrix
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 y_train_perfect_predictions = y_train_5 # притворись, что мы достигли совершенства
 print(confusion_matrix(y_train_5, y_train_perfect_predictions))
 # array([[54579, 0],
 #        [ 0, 5421]])

Аккуратность (англ. Accuracy)

Интуитивно понятной, очевидной и почти неиспользуемой метрикой является accuracy — доля правильных ответов алгоритма:

Эта метрика бесполезна в задачах с неравными классами, что как вариант можно исправить с помощью алгоритмов сэмплирования и это легко показать на примере.

Допустим, мы хотим оценить работу спам-фильтра почты. У нас есть 100 не-спам писем, 90 из которых наш классификатор определил верно (True Negative = 90, False Positive = 10), и 10 спам-писем, 5 из которых классификатор также определил верно (True Positive = 5, False Negative = 5).
Тогда accuracy:

Однако если мы просто будем предсказывать все письма как не-спам, то получим более высокую аккуратность:

При этом, наша модель совершенно не обладает никакой предсказательной силой, так как изначально мы хотели определять письма со спамом. Преодолеть это нам поможет переход с общей для всех классов метрики к отдельным показателям качества классов.

 # код для для подсчета аккуратности:
 # Пример классификатора, способного проводить различие между всего лишь двумя
 # классами, "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.metrics import accuracy_score
 from sklearn.linear_model import SGDClassifier
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распозновать пятерки на целом обучающем наборе
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 # print(confusion_matrix(y_train_5, y_train_pred))
 # array([[53892, 687]
 #        [ 1891, 3530]])
 print(accuracy_score(y_train_5, y_train_pred)) # == (53892 + 3530) / (53892 + 3530  + 1891 +687)
 
 # 0.9570333333333333

Точность (англ. Precision)

Точностью (precision) называется доля правильных ответов модели в пределах класса — это доля объектов действительно принадлежащих данному классу относительно всех объектов которые система отнесла к этому классу.

Именно введение precision не позволяет нам записывать все объекты в один класс, так как в этом случае мы получаем рост уровня False Positive.

Полнота (англ. Recall)

Полнота — это доля истинно положительных классификаций. Полнота показывает, какую долю объектов, реально относящихся к положительному классу, мы предсказали верно.

Полнота (recall) демонстрирует способность алгоритма обнаруживать данный класс вообще.

Имея матрицу ошибок, очень просто можно вычислить точность и полноту для каждого класса. Точность (precision) равняется отношению соответствующего диагонального элемента матрицы и суммы всей строки класса. Полнота (recall) — отношению диагонального элемента матрицы и суммы всего столбца класса. Формально:

Результирующая точность классификатора рассчитывается как арифметическое среднее его точности по всем классам. То же самое с полнотой. Технически этот подход называется macro-averaging.

 # код для для подсчета точности и полноты:
 # Пример классификатора, способного проводить различие между всего лишь двумя
 # классами, "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.metrics import precision_score, recall_score
 from sklearn.linear_model import SGDClassifier
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распозновать пятерки на целом обучающем наборе
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 # print(confusion_matrix(y_train_5, y_train_pred))
 # array([[53892, 687]
 #        [ 1891, 3530]])
 print(precision_score(y_train_5, y_train_pred)) # == 3530 / (3530 + 687)
 print(recall_score(y_train_5, y_train_pred)) # == 3530 / (3530 + 1891)
   
 # 0.8370879772350012
 # 0.6511713705958311

F-мера (англ. F-score)

Precision и recall не зависят, в отличие от accuracy, от соотношения классов и потому применимы в условиях несбалансированных выборок.
Часто в реальной практике стоит задача найти оптимальный (для заказчика) баланс между этими двумя метриками. Понятно что чем выше точность и полнота, тем лучше. Но в реальной жизни максимальная точность и полнота не достижимы одновременно и приходится искать некий баланс. Поэтому, хотелось бы иметь некую метрику которая объединяла бы в себе информацию о точности и полноте нашего алгоритма. В этом случае нам будет проще принимать решение о том какую реализацию запускать в производство (у кого больше тот и круче). Именно такой метрикой является F-мера.

F-мера представляет собой гармоническое среднее между точностью и полнотой. Она стремится к нулю, если точность или полнота стремится к нулю.

Данная формула придает одинаковый вес точности и полноте, поэтому F-мера будет падать одинаково при уменьшении и точности и полноты. Возможно рассчитать F-меру придав различный вес точности и полноте, если вы осознанно отдаете приоритет одной из этих метрик при разработке алгоритма:

где принимает значения в диапазоне если вы хотите отдать приоритет точности, а при приоритет отдается полноте. При формула сводится к предыдущей и вы получаете сбалансированную F-меру (также ее называют ).

F-мера достигает максимума при максимальной полноте и точности, и близка к нулю, если один из аргументов близок к нулю.

F-мера является хорошим кандидатом на формальную метрику оценки качества классификатора. Она сводит к одному числу две других основополагающих метрики: точность и полноту. Имея «F-меру» гораздо проще ответить на вопрос: «поменялся алгоритм в лучшую сторону или нет?»

 # код для подсчета метрики F-mera:
 # Пример классификатора, способного проводить различие между всего лишь двумя
 # классами, "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.linear_model import SGDClassifier
 from sklearn.metrics import f1_score
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распознавать пятерки на целом обучающем наборе
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 print(f1_score(y_train_5, y_train_pred))
 
 # 0.7325171197343846

ROC-кривая

Кривая рабочих характеристик (англ. Receiver Operating Characteristics curve).
Используется для анализа поведения классификаторов при различных пороговых значениях.
Позволяет рассмотреть все пороговые значения для данного классификатора.
Показывает долю ложно положительных примеров (англ. false positive rate, FPR) в сравнении с долей истинно положительных примеров (англ. true positive rate, TPR).

Доля FPR — это пропорция отрицательных образцов, которые были некорректно классифицированы как положительные.

,

где TNR — доля истинно отрицательных классификаций (англ. Тrие Negative Rate), пред­ставляющая собой пропорцию отрицательных образцов, которые были кор­ректно классифицированы как отрицательные.

Доля TNR также называется специфичностью (англ. specificity). Следовательно, ROC-кривая изображает чувствительность (англ. seпsitivity), т.е. полноту, в срав­нении с разностью 1 — specificity.

Прямая линия по диагонали представляет ROC-кривую чисто случайного классификатора. Хороший классификатор держится от указанной линии настолько далеко, насколько это
возможно (стремясь к левому верхнему углу).

Один из способов сравнения классификаторов предусматривает измере­ние площади под кривой (англ. Area Under the Curve — AUC). Безупречный клас­сификатор будет иметь площадь под ROC-кривой (ROC-AUC), равную 1, тогда как чисто случайный классификатор — площадь 0.5.

 # Код отрисовки ROC-кривой
 # На примере классификатора, способного проводить различие между всего лишь двумя классами
 # "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 from sklearn.metrics import roc_curve
 import matplotlib.pyplot as plt
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.linear_model import SGDClassifier
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5)  # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распозновать пятерки на целом обучающем наборе
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3, method="decision_function")
 fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)
 def plot_roc_curve(fpr, tpr, label=None):
     plt.plot(fpr, tpr, linewidth=2, label=label)
     plt.plot([0, 1], [0, 1], 'k--') # dashed diagonal
     plt.xlabel('False Positive Rate, FPR (1 - specificity)')
     plt.ylabel('True Positive Rate, TPR (Recall)')
     plt.title('ROC curve')
     plt.savefig("ROC.png")
 plot_roc_curve(fpr, tpr)
 plt.show()

Precison-recall кривая

Чувствительность к соотношению классов.
Рассмотрим задачу выделения математических статей из множества научных статей. Допустим, что всего имеется 1.000.100 статей, из которых лишь 100 относятся к математике. Если нам удастся построить алгоритм , идеально решающий задачу, то его TPR будет равен единице, а FPR — нулю. Рассмотрим теперь плохой алгоритм, дающий положительный ответ на 95 математических и 50.000 нематематических статьях. Такой алгоритм совершенно бесполезен, но при этом имеет TPR = 0.95 и FPR = 0.05, что крайне близко к показателям идеального алгоритма.
Таким образом, если положительный класс существенно меньше по размеру, то AUC-ROC может давать неадекватную оценку качества работы алгоритма, поскольку измеряет долю неверно принятых объектов относительно общего числа отрицательных. Так, алгоритм , помещающий 100 релевантных документов на позиции с 50.001-й по 50.101-ю, будет иметь AUC-ROC 0.95.

Precison-recall (PR) кривая. Избавиться от указанной проблемы с несбалансированными классами можно, перейдя от ROC-кривой к PR-кривой. Она определяется аналогично ROC-кривой, только по осям откладываются не FPR и TPR, а полнота (по оси абсцисс) и точность (по оси ординат). Критерием качества семейства алгоритмов выступает площадь под PR-кривой (англ. Area Under the Curve — AUC-PR)

 # Код отрисовки Precison-recall кривой
 # На примере классификатора, способного проводить различие между всего лишь двумя классами
 # "пятерка" и "не пятерка" из набора рукописных цифр MNIST
 from sklearn.metrics import precision_recall_curve
 import matplotlib.pyplot as plt
 import numpy as np
 from sklearn.datasets import fetch_openml
 from sklearn.model_selection import cross_val_predict
 from sklearn.linear_model import SGDClassifier
 mnist = fetch_openml('mnist_784', version=1)
 X, y = mnist["data"], mnist["target"]
 y = y.astype(np.uint8)
 X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
 y_train_5 = (y_train == 5) # True для всех пятерок, False для в сех остальных цифр. Задача опознать пятерки
 y_test_5 = (y_test == 5)
 sgd_clf = SGDClassifier(random_state=42) # классификатор на основе метода стохастического градиентного спуска (Stochastic Gradient Descent SGD)
 sgd_clf.fit(X_train, y_train_5) # обучаем классификатор распозновать пятерки на целом обучающем наборе
 y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
 y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3, method="decision_function")
 precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)
 def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):
     plt.plot(recalls, precisions, linewidth=2)
     plt.xlabel('Recall')
     plt.ylabel('Precision')
     plt.title('Precision-Recall curve')
     plt.savefig("Precision_Recall_curve.png")
 plot_precision_recall_vs_threshold(precisions, recalls, thresholds)
 plt.show()

Оценки качества регрессии

Наиболее типичными мерами качества в задачах регрессии являются

Средняя квадратичная ошибка (англ. Mean Squared Error, MSE)

MSE применяется в ситуациях, когда нам надо подчеркнуть большие ошибки и выбрать модель, которая дает меньше больших ошибок прогноза. Грубые ошибки становятся заметнее за счет того, что ошибку прогноза мы возводим в квадрат. И модель, которая дает нам меньшее значение среднеквадратической ошибки, можно сказать, что что у этой модели меньше грубых ошибок.

и

Cредняя абсолютная ошибка (англ. Mean Absolute Error, MAE)

Среднеквадратичный функционал сильнее штрафует за большие отклонения по сравнению со среднеабсолютным, и поэтому более чувствителен к выбросам. При использовании любого из этих двух функционалов может быть полезно проанализировать, какие объекты вносят наибольший вклад в общую ошибку — не исключено, что на этих объектах была допущена ошибка при вычислении признаков или целевой величины.

Среднеквадратичная ошибка подходит для сравнения двух моделей или для контроля качества во время обучения, но не позволяет сделать выводов о том, на сколько хорошо данная модель решает задачу. Например, MSE = 10 является очень плохим показателем, если целевая переменная принимает значения от 0 до 1, и очень хорошим, если целевая переменная лежит в интервале (10000, 100000). В таких ситуациях вместо среднеквадратичной ошибки полезно использовать коэффициент детерминации —

Коэффициент детерминации

Коэффициент детерминации измеряет долю дисперсии, объясненную моделью, в общей дисперсии целевой переменной. Фактически, данная мера качества — это нормированная среднеквадратичная ошибка. Если она близка к единице, то модель хорошо объясняет данные, если же она близка к нулю, то прогнозы сопоставимы по качеству с константным предсказанием.

Средняя абсолютная процентная ошибка (англ. Mean Absolute Percentage Error, MAPE)

Это коэффициент, не имеющий размерности, с очень простой интерпретацией. Его можно измерять в долях или процентах. Если у вас получилось, например, что MAPE=11.4%, то это говорит о том, что ошибка составила 11,4% от фактических значений.
Основная проблема данной ошибки — нестабильность.

Корень из средней квадратичной ошибки (англ. Root Mean Squared Error, RMSE)

Примерно такая же проблема, как и в MAPE: так как каждое отклонение возводится в квадрат, любое небольшое отклонение может значительно повлиять на показатель ошибки. Стоит отметить, что существует также ошибка MSE, из которой RMSE как раз и получается путем извлечения корня.

Cимметричная MAPE (англ. Symmetric MAPE, SMAPE)

Средняя абсолютная масштабированная ошибка (англ. Mean absolute scaled error, MASE)

MASE является очень хорошим вариантом для расчета точности, так как сама ошибка не зависит от масштабов данных и является симметричной: то есть положительные и отрицательные отклонения от факта рассматриваются в равной степени.
Обратите внимание, что в MASE мы имеем дело с двумя суммами: та, что в числителе, соответствует тестовой выборке, та, что в знаменателе — обучающей. Вторая фактически представляет собой среднюю абсолютную ошибку прогноза. Она же соответствует среднему абсолютному отклонению ряда в первых разностях. Эта величина, по сути, показывает, насколько обучающая выборка предсказуема. Она может быть равна нулю только в том случае, когда все значения в обучающей выборке равны друг другу, что соответствует отсутствию каких-либо изменений в ряде данных, ситуации на практике почти невозможной. Кроме того, если ряд имеет тенденцию к росту либо снижению, его первые разности будут колебаться около некоторого фиксированного уровня. В результате этого по разным рядам с разной структурой, знаменатели будут более-менее сопоставимыми. Всё это, конечно же, является очевидными плюсами MASE, так как позволяет складывать разные значения по разным рядам и получать несмещённые оценки.

Недостаток MASE в том, что её тяжело интерпретировать. Например, MASE=1.21 ни о чём, по сути, не говорит. Это просто означает, что ошибка прогноза оказалась в 1.21 раза выше среднего абсолютного отклонения ряда в первых разностях, и ничего более.

Кросс-валидация

Хороший способ оценки модели предусматривает применение кросс-валидации (cкользящего контроля или перекрестной проверки).

В этом случае фиксируется некоторое множество разбиений исходной выборки на две подвыборки: обучающую и контрольную. Для каждого разбиения выполняется настройка алгоритма по обучающей подвыборке, затем оценивается его средняя ошибка на объектах контрольной подвыборки. Оценкой скользящего контроля называется средняя по всем разбиениям величина ошибки на контрольных подвыборках.

Примечания

1. [1] Лекция «Оценивание качества» на www.coursera.org
2. [2] Лекция на www.stepik.org о кросвалидации
3. [3] Лекция на www.stepik.org о метриках качества, Precison и Recall
4. [4] Лекция на www.stepik.org о метриках качества, F-мера
5. [5] Лекция на www.stepik.org о метриках качества, примеры

См. также

• Оценка качества в задаче кластеризации
• Кросс-валидация

Источники информации

1. [6] Соколов Е.А. Лекция линейная регрессия
2. [7] — Дьяконов А. Функции ошибки / функционалы качества
3. [8] — Оценка качества прогнозных моделей
4. [9] — HeinzBr Ошибка прогнозирования: виды, формулы, примеры
5. [10] — egor_labintcev Метрики в задачах машинного обучения
6. [11] — grossu Методы оценки качества прогноза
7. [12] — К.В.Воронцов, Классификация
8. [13] — К.В.Воронцов, Скользящий контроль

Расшифровка матрицы путаницы

  Перевод

  Ссылка на автора

В случае проблемы классификации, имеющей только одну точность классификации, может не дать вам полную картину. Таким образом, матрица путаницы или матрица ошибок используется для суммирования производительности алгоритма классификации.

Вычисление матрицы путаницы может дать вам представление о том, где модель классификации верна и какие ошибки она допускает.

Путаница путаница используется для проверки производительности модели классификации на наборе тестовых данных, для которых известны истинные значения. Большинство показателей эффективности, таких как точность, отзыв, рассчитываются из матрицы путаницы.

Эта статья направлена ​​на:
1. Что такое матрица путаницы и зачем она нужна?
2. Как рассчитать путаницу для двухклассовой задачи классификации на примере кошки-собаки.
3. Как создать путаницу в Python & R.
4. Краткое изложение и интуиция о различных мерах: точность, отзыв, точность и специфика

1. Матрица путаницы:

Матрица путаницы предоставляет сводку прогнозирующих результатов в задаче классификации. Правильные и неправильные прогнозы суммируются в таблице со своими значениями и разбиваются по каждому классу.

Мы не можем полагаться на одно значение точности в классификации, когда классы не сбалансированы. Например, у нас есть набор данных из 100 пациентов, 5 из которых имеют диабет, а 95 здоровы. Однако, если наша модель только предсказывает класс большинства, то есть все 100 человек здоровы, даже если у нас точность классификации составляет 95%. Поэтому нам нужна матрица путаницы.

2. Рассчитайте матрицу путаницы:

Давайте возьмем пример:

У нас всего 10 кошек и собак, и наша модель предсказывает, кошка это или нет.

Фактические значения = [«собака», «кошка», «собака», «кошка», «собака», «собака», «кошка», «собака», «кошка», «собака» »]
Прогнозируемые значения = [«собака», «собака», «собака», «собака», «собака», «собака», «кошка», «кошка», «кошка», «кошка»]

Помните, мы описываем прогнозируемые значения как положительные / отрицательные, а фактические значения как истинные / ложные.

Определение терминов:
Настоящий позитив: вы предсказали позитив, и это правда. Вы предсказали, что животное — это кошка, и это действительно так.

True Negative: вы предсказали отрицательный результат, и это правда. Вы предсказали, что животное — это не кошка, и на самом деле это не так (это собака).

Ложный положительный результат (ошибка типа 1). Вы предсказали положительный результат, и это неверно. Вы предсказали, что животное — это кошка, но на самом деле это не так (это собака).

Ложное отрицание (ошибка типа 2). Вы прогнозировали отрицательное значение, и оно ложно. Вы предсказали, что животное не кошка, но на самом деле это так.

Точность классификации:
Точность классификации определяется соотношением:

Напомним (Чувствительность ака):
Напомним, определяется как отношение общего количества правильно классифицированных положительных классов к общему количеству положительных классов. Или из всех положительных классов, сколько мы предсказали правильно. Отзыв должен быть высоким.

Точность:
Точность определяется как отношение общего количества правильно классифицированных положительных классов к общему количеству предсказанных положительных классов. Или из всех прогнозирующих положительных классов, сколько мы предсказали правильно. Точность должна быть высокой.

Уловка, чтобы помнить:дозрение имеетдоДиктивные результаты в знаменателе.

F-оценка или F1-оценка:
Сложно сравнивать две модели с разными Precision и Recall. Поэтому, чтобы сделать их сопоставимыми, мы используем F-Score. Это Гармоническое Средство Точности и Вспомнить. По сравнению с арифметическим средним, гармоническое среднее наказывает более экстремальные значения. F-оценка должна быть высокой.

Специфичность:
Специфичность определяет долю фактических негативов, которые правильно определены.

Пример для интерпретации матрицы путаницы:
Давайте вычислим матрицу путаницы, используя приведенный выше пример с кошкой и собакой:

Точность классификации:
Точность = (TP + TN) / (TP + TN + FP + FN) = (3 + 4) / (3 + 4 + 2 + 1) = 0,70

Отзыв:Напомним, дает нам представление о том, когда на самом деле да, как часто он предсказывает да.
Напомним = TP / (TP + FN) = 3 / (3 + 1) = 0,75

Точность:Точность говорит нам о том, когда он предсказывает, да, как часто это правильно.
Точность = TP / (TP + FP) = 3 / (3 + 2) = 0,60

F-оценка:
F-оценка = (2 * Recall * Precision) / (Recall + Presision) = (2 * 0,75 * 0,60) / (0,75 + 0,60) = 0,67

Специфичность:
Специфичность = TN / (TN + FP) = 4 / (4 + 2) = 0,67

3. Создать путаницу в Python & R

Давайте используем и коды Python, и R, чтобы понять приведенный выше пример с собакой и кошкой, который поможет вам лучше понять, что вы узнали о матрице путаницы до сих пор.

ПИТОН:Сначала давайте возьмем код Python для создания матрицы путаницы. Мы должны импортировать модуль матрицы путаницы из библиотеки sklearn, которая помогает нам генерировать матрицу путаницы

Ниже приведена реализация приведенного выше объяснения в Python:

OUTPUT ->Confusion Matrix :
[[3 1]
 [2 4]]
Accuracy Score : 0.7
Classification Report : 
        precision    recall  f1-score   supportcat       0.60      0.75      0.67         4
dog       0.80      0.67      0.73         6micro avg          0.70      0.70      0.70        10
macro avg          0.70      0.71      0.70        10
weighted avg       0.72      0.70      0.70        10

Р:Давайте теперь используем R-код для создания матрицы путаницы. Мы будем использовать библиотеку карет в R для вычисления матрицы путаницы.

OUTPUT ->Confusion Matrix and Statistics             Reference
Prediction   0 1
           0 4 1
           1 2 3Accuracy : 0.7 
95% CI : (0.3475, 0.9333)
No Information Rate : 0.6 
P-Value [Acc > NIR] : 0.3823Kappa : 0.4Mcnemar's Test P-Value : 1.0000Sensitivity : 0.6667 
Specificity : 0.7500 
Pos Pred Value : 0.8000 
Neg Pred Value : 0.6000 
Prevalence : 0.6000 
Detection Rate : 0.4000 
Detection Prevalence : 0.5000 
Balanced Accuracy : 0.7083'Positive' Class : 0

4. Резюме:

• Точность — это насколько вы уверены в своих истинных положительных сторонах. Вспомните, насколько вы уверены, что не пропускаете ни одного позитива.
• выберитеОтзывесли возникновениеложные негативы недопустимы / недопустимы.Например, в случае диабета у вас было бы больше ложных срабатываний (ложных срабатываний) вместо сохранения ложных отрицательных.
• выберитеточностьесли хочешь быть побольшеуверен в своих истинных позитивах, Например, в случае спам-писем вы бы предпочли иметь несколько спам-писем в вашем почтовом ящике, а не обычные электронные письма в вашем ящике для спама. Вы хотели бы быть уверены, что электронная почта X является спамом, прежде чем мы поместим ее в ящик для спама.
• выберитеспецифичностьесли хочешьпокрыть все истинные негативы,то есть мы не хотим ложных срабатываний или ложных срабатываний. Например, в случае теста на наркотики, при котором все люди с положительным тестом немедленно попадут в тюрьму, вы не хотели бы, чтобы кто-либо без наркотиков отправлялся в тюрьму.

Мы можем сделать вывод, что:

• Значение точности 70% означает, что идентификация 3 из каждых 10 кошек неверна, а 7 — правильна.
• Точность 60% означает, что метка 4 из каждых 10 кошек — это не кошка (то есть собака), а 6 — кошки.
• Напомним, что значение 70% означает, что 3 из каждых 10 кошек в действительности пропущены нашей моделью, а 7 правильно определены как кошки.
• Значение специфичности, равное 60%, означает, что 4 из каждых 10 собак (то есть не кошек) в действительности помечены как кошки, а 6 — как собаки.

Если у вас есть какие-либо комментарии или вопросы, не стесняйтесь оставлять свои отзывы ниже. Вы всегда можете связаться со мной по LinkedIn,

Были ли вы в ситуации, когда вы ожидали, что ваша модель машинного обучения должна работать очень хорошо, но у нее была низкая точность? Вы проделали всю тяжелую работу — так где же модель классификации сработала не так? Как это исправить?

Существует множество способов оценить эффективность вашей модели классификации, но ни один из них не выдержал испытания временем, кроме матрицы ошибок. Она помогает нам оценить, как наша модель работала, где она пошла не туда, и предлагает нам рекомендации по исправлению нашего пути.

В этой статье мы рассмотрим, как матрица ошибок дает целостное представление об эффективности вашей модели. И, в отличие от названия, вы поймете, что матрица ошибок — довольно простая, но мощная концепция. Итак, давайте раскроем тайну матрицы ошибок!

Что такое матрица ошибок?

Вопрос на миллион долларов — что такое, в конце концов, матрица ошибок?

Матрица ошибок — это матрица размером N x N, используемая для оценки эффективности модели классификации, где N — количество целевых классов. Матрица сравнивает фактические целевые значения с предсказанными моделью машинного обучения. Это дает нам целостное представление о том, насколько хорошо работает наша классификационная модель и какие ошибки она допускает.

Для задачи двоичной классификации у нас будет матрица 2 x 2, как показано ниже, с 4 значениями:

Расшифруем матрицу:

Но подождите — что здесь TP, FP, FN и TN? Это важнейшая часть матрицы ошибок. Давайте разберемся с каждым термином ниже.

Понимание True Positive, True Negative, False Positive и False Negative в матрице ошибок

True Positive (TP)

True Negative (TN)

False Positive (FP) — ошибка 1-го типа

False Negative (FN) — ошибка 2-го типа

Позвольте мне привести пример, чтобы лучше это понять. Предположим, у нас есть набор данных классификации с 1000 точками данных. Мы подгоняем на нем классификатор и получаем следующую матрицу ошибок:

Различные значения матрицы ошибок будут следующими:

Это оказался довольно приличный классификатор для нашего набора данных, учитывая относительно большее количество истинно положительных и истинно отрицательных значений.

Помните об ошибках 1-го и 2-го типа. Интервьюеры любят спрашивать, в чем разница между ними!

Зачем нам нужна матрица ошибок?

Прежде чем ответить на этот вопрос, давайте подумаем о проблеме гипотетической классификации.

Допустим, вы хотите предсказать, сколько людей инфицировано заразным вирусом, до того, как у них проявятся симптомы, и изолировать их от здорового населения. Двумя значениями для нашей целевой переменной будут: Sick и Not Sick.

Теперь вы, должно быть, задаетесь вопросом — зачем нам матрица ошибок, когда у нас есть наш вечный друг — Точность? Что ж, посмотрим, где точность не работает.

Наш набор данных является примером несбалансированного набора данных. Имеется 947 точек данных для отрицательного класса и 3 точки данных для положительного класса. Вот как мы рассчитаем точность:

Посмотрим, как работает наша модель:

Общие значения результатов:

TP = 30, TN = 930, FP = 30, FN = 10

Итак, точность для нашей модели:

96%! Неплохо!

Но это дает неверное представление о результате. Подумайте об этом.

Наша модель гласит: «Я могу предсказать заболевание в 96% случаев». Однако она делает наоборот. Это предсказание людей, которые не заболеют с точностью 96%, пока больные распространяют вирус!

Как вы думаете, это правильный показатель для нашей модели, учитывая серьезность проблемы? Разве мы не должны измерять, сколько положительных случаев мы можем правильно предсказать, чтобы остановить распространение заразного вируса? Или, из правильно спрогнозированных случаев сколько положительных случаев для проверки надежности нашей модели?

Здесь мы сталкиваемся с двойным понятием «точность (Precision) и полнота (Recall)».

Precision vs. Recall

Точность говорит нам, сколько из правильно предсказанных случаев действительно оказались положительными.

Вот как рассчитать точность:

Это определило бы надежность нашей модели.

Полнота сообщает нам, сколько реальных положительных случаев мы смогли правильно предсказать с помощью нашей модели.

А вот как мы можем рассчитать полноту:

Мы можем легко рассчитать точность и полноту для нашей модели, подставив значения в приведенные выше уравнения:

50% процентов правильно предсказанных случаев оказались положительными. В то время как 75% положительных результатов были успешно предсказаны нашей моделью. Потрясающие!

Точность — полезный показатель в тех случаях, когда ложноположительный результат важнее, чем ложноотрицательный.

Точность важна в системах рекомендаций по музыке или видео, на веб-сайтах электронной коммерции и т. д. Неправильные результаты могут привести к оттоку клиентов и нанести вред бизнесу.

Полнота — полезный показатель в случаях, когда ложноотрицательный результат важнее ложноположительного.

Полнота важна в медицинских случаях, когда не имеет значения, что возникает ложная тревога, но реальные положительные случаи не должны оставаться незамеченными!

В нашем примере полнота была бы лучшим показателем, потому что мы не хотим, чтобы случайно выписали инфицированного человека и позволили ему смешаться со здоровым населением, тем самым распространяя заразный вирус. Теперь вы можете понять, почему точность была плохим показателем для нашей модели.

Но будут случаи, когда нет четкой разницы между тем, что важнее: точность или полнота. Что нам делать в таких случаях? Мы их совмещаем!

F1-Score

На практике, когда мы пытаемся повысить точность нашей модели, полнота снижается, и наоборот. F1-Score отражает обе тенденции в одном значении:

F1-Score представляет собой гармоничное среднее значение точности и полноты, поэтому дает общее представление об этих двух показателях. Оно максимально, когда точность равно полноте.

Но здесь есть одна загвоздка. Интерпретируемость оценки F1 оставляет желать лучшего. Это означает, что мы не знаем, чего добивается наш классификатор — точности или полноты? Итак, мы используем его в сочетании с другими оценочными метриками, что дает нам полную картину результата.

Матрица ошибок с использованием scikit-learn в Python

Вы знаете теорию — теперь давайте применим ее на практике. Давайте запрограммируем матрицу ошибок с помощью библиотеки Scikit-learn (sklearn) на Python.

# confusion matrix in sklearn

from sklearn.metrics import confusion_matrix

3 from sklearn.metrics import classification_report

# actual values

actual = [1,0,0,1,0,0,1,0,0,1]

# predicted values

predicted = [1,0,0,1,0,0,0,1,0,0]

# confusion matrix

matrix = confusion_matrix(actual,predicted, labels=[1,0])

print(‘Confusion matrix : n’,matrix)

# outcome values order in sklearn

tp, fn, fp, tn = confusion_matrix(actual,predicted,labels=[1,0]).reshape(-1)

print(‘Outcome values : n’, tp, fn, fp, tn)

# classification report for precision, recall f1-score and accuracy

matrix = classification_report(actual,predicted,labels=[1,0])

print(‘Classification report : n’,matrix)

Sklearn имеет две отличные функции: confusion_matrix() и classification_report().

Mirco average — это оценка точности/полноты/f1, рассчитанная для всех классов.

Macro average — это среднее значение точности/полноты/f1-score.

Weighted average — это просто средневзвешенное значение точности/полноты/f1-score.

Матрица ошибок для мультиклассовой классификации

Как матрица ошибок будет работать для задачи классификации нескольких классов? Мы рассмотрим и этот случай.

Давайте нарисуем матрицу ошибок для мультиклассовой задачи, в которой мы должны предсказать, любит ли человек Facebook, Instagram или Snapchat. Матрица ошибок будет иметь вид 3 x 3:

true positive, true negative, false positive и false negative для каждого класса будут вычисляться путем сложения значений ячеек следующим образом:

Вот и все! Вы готовы расшифровать любую матрицу ошибок размером N x N!

Заключение

И вдруг матрица ошибок перестает быть такой запутанной! Эта статья должна дать вам прочную основу для интерпретации и использования матрицы ошибок для алгоритмов классификации в машинном обучении.

Вскоре мы выпустим статью о кривой AUC-ROC и продолжим наше обсуждение там. До этого не теряйте надежды на свою модель классификации, возможно, вы просто используете неправильную метрику оценки!