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

В компьютерном зрении обнаружение объекта — это проблема определения местоположения одного или нескольких объектов на изображении. Помимо традиционных методов обнаружения, продвинутые модели глубокого обучения, такие как 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. Названия строк представляют собой эталонные метки, а названия столбцов — предсказанные.

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

True или False.
Positive или Negative.

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

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

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

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

Оценка моделей ML/DL: матрица ошибок, Accuracy, Precision и Recall

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

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

Предположим, имеется 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(). Мы передадим в функцию следующие параметры:

y_true: эталонные метки.
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]]

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

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

Accuracy
Precision
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 высока, когда:

Модель делает много корректных предсказаний класса Positive (максимизирует True Positive метрику).
Модель делает меньше неверных 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 применяется для расчета каждого вышеперечисленного показателя.

Источник

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

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

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

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

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

Матрица ошибок — это матрица размером 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-го типа

Прогнозируемое значение было предсказано неверно.
Фактическое значение было отрицательным, но модель предсказала положительное значение.
Также известна как ошибка 1-го типа.

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

Прогнозируемое значение было предсказано неверно.
Фактическое значение было положительным, но модель предсказала отрицательное значение.
Также известна как ошибка 2-го типа.

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

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

True Positive (TP) = 560; это означает, что 560 положительных точек данных были правильно классифицированы моделью.
True Negative (TN) = 330; это означает, что 330 отрицательных точек данных были правильно классифицированы моделью.
False Positive (FP) = 60; это означает, что 60 отрицательных точек данных были неправильно классифицированы моделью как положительные.
False Negative (FN) = 50; это означает, что 50 положительных точек данных были неправильно классифицированы моделью как отрицательные.

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

Помните об ошибках 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().

Sklearn confusion_matrix()

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

Sklearn classes_report()

выводит точность, полноту и f1-score для каждого целевого класса. В дополнение к этому, она также имеет некоторые дополнительные значения: micro avg, macro avg и weighted avg.

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 и продолжим наше обсуждение там. До этого не теряйте надежды на свою модель классификации, возможно, вы просто используете неправильную метрику оценки!

Источник

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

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

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

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

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

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

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

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

True или False.
Positive или Negative.

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

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

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

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

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

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

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

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

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

y_true: эталонные метки.
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)

import numpy

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

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

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)

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]]

Accuracy
Precision
Recall

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

Метрика Accuracy

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

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

Precision

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

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

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

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

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?

Вывод

Вступление

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

Итак, этот пост будет о 7 наиболее часто используемых показателях MC: точность, отзывчивость, оценка F1, оценка ROC AUC, оценка Коэна Каппы, коэффициент корреляции Мэтью и потери журнала. Вы узнаете, как они рассчитываются, их нюансы в Sklearn и как использовать их в своем рабочем процессе.

Интерпретация матрицы путаницы N на N

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

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

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

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

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

После определения положительного и отрицательного классов определите истинно положительные, истинно отрицательные, ложные и ложно отрицательные. Что касается нашей проблемы:

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

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

От двоичных показателей к мультиклассу

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

Во-первых, мультиклассовая проблема разбивается на серию двоичных задач с использованием подходов One-vs-One (OVO) или One-vs-Rest (OVR, также называемого One-vs-All). OVO имеет вычислительные недостатки, поэтому профессионалы предпочитают подход OVR. Поскольку я подробно обсуждал различия между этими двумя подходами в моей последней статье, сегодня мы сосредоточимся только на OVR.

По сути, стратегия One-vs-Rest преобразует мультиклассовую задачу в серию бинарных задач для каждого класса в цели. Например, классификация 4 типов алмазов может быть разделена на 4 задачи с помощью OVR:

Задача 1: идеально против [премиум-класса, хорошо, удовлетворительно], т. Е. Идеально или не идеально
Задача 2: премия по сравнению с [идеально, хорошо, удовлетворительно] — т. Е. Премия по сравнению с не премией
Задача 3: хорошее против [идеальное, премиальное, удовлетворительное], т. Е. Хорошее против плохого.
Задача 4: справедливо против [идеально, премиум-класса, хорошо] — т. Е. Справедливо или нечестно.

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

В частности, есть 3 метода усреднения, применимые к мультиклассовой классификации:

макрос: это простое среднее арифметическое всех показателей по классам. Этот метод дает равные веса всем классам, что делает его хорошим вариантом для сбалансированных задач классификации.
взвешенный: учитывает дисбаланс классов путем вычисления среднего двоичных показателей, взвешенных по количеству выборок каждого класса в целевом объекте. Если 3 (оценки точности) для 3 классов составляют: класс 1 (0,85), класс 2 (0,80) и класс 3 (0,89), средневзвешенное значение будет вычислено путем умножения каждой оценки на число. вхождений каждого класса и деление на общее количество выборок.
микро: то же, что и точность. Микроусреднение находится путем деления суммы диагональных ячеек матрицы на сумму всех ячеек, то есть точности. Поскольку точность — такой показатель, который вводит в заблуждение, этот метод усреднения используется редко.

Теперь, наконец, перейдем к реальным показателям!

Точность и отзывчивость для мультиклассовой классификации

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

Точность рассчитывается путем деления истинных положительных результатов на сумму истинных положительных и ложных положительных результатов (правило тройного p):

Давайте посчитаем точность для идеального класса. Вот матрица путаницы для справки:

Истинные плюсы для идеальных бриллиантов — это верхняя левая ячейка (22). Ложные срабатывания — это все ячейки, в которых другие типы бриллиантов считаются идеальными. Это ячейки под верхней левой ячейкой (5 + 2 + 9 = 19). Итак, точность будет:

Точность (идеальная): 22 / (22 + 19) = 0,536 — ужасная оценка.

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

Напомним, отвечает на вопрос: «Какая часть фактических положительных результатов классифицирована правильно?» Он рассчитывается путем деления количества истинных положительных результатов на сумму истинных положительных и ложно отрицательных результатов.

Рассчитаем для бриллиантов премиум-класса.

Есть 27 истинных положительных результатов (2-я строка, 2-й столбец). Ложноотрицательными будут любые случаи, когда бриллианты премиум-класса были классифицированы как идеальные, хорошие или удовлетворительные. Это будут ячейки слева и справа от истинно положительной ячейки (5 + 7 + 6 = 18). Итак, отзыв будет:

Отзыв (премия): 27 / (27 + 18) = 0,6 — тоже не очень хороший результат.

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

Если вы хотите увидеть точность и отзыв для всех классов, их макросов и средневзвешенных значений, вы можете использовать функцию Sklearn classification_report. Предполагая, что наши метки находятся в y_test, а прогнозы в y_pred, отчет по классификации бриллиантов будет:

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

Оценка F1 для мультиклассовой классификации

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

Здесь на помощь приходит оценка F1. Она рассчитывается путем принятия среднего гармонического значения точности и отзыва и варьируется от 0 до 1.

Почему нужно использовать среднее гармоническое, а не простое арифметическое? Что ж, гармоническое среднее имеет приятное арифметическое свойство, представляющее действительно сбалансированное среднее. Если точность или отзыв низкие, это значительно страдает. Например, предположим, что мы сравниваем два классификатора друг с другом. Точность и отзывчивость первого классификатора составляют 0,9, 0,9, а точность и полноту второго классификатора — 1,0 и 0,7. Расчет F1 для обоих дает нам 0,9 и 0,82. Как видите, низкий показатель запоминания второго классификатора снизил оценку.

Вы можете увидеть оба усредненных результата F1, используя выходные данные отчета о классификации:

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

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

Оценка ROC AUC для мультиклассовой классификации

Другой часто используемый показатель в двоичной классификации — это площадь под кривой рабочих характеристик приемника (ROC AUC или AUROC). Он количественно определяет способность модели различать каждый класс. Метрика используется только с классификаторами, которые могут генерировать вероятности членства в классе. С точки зрения оценщиков Sklearn, это модели, у которых есть predict_proba() метод.

Например, если цель содержит класс кошек и собак, тогда классификатор с методом predict_proba может генерировать вероятности членства, такие как 0,35 для кошки и 0,65 для собаки для каждой выборки. Затем каждое предсказание классифицируется на основе порогового значения решения, например 0,5. Прежде чем объяснять AUROC дальше, давайте подробно рассмотрим, как он рассчитывается для MC.

После выбора двоичного классификатора с методом predict_proba он используется для генерации вероятностей членства для первой двоичной задачи в OVR. Затем выбирается начальный порог принятия решения, близкий к 0. Используя порог, делаются прогнозы и создается матрица неточностей. Из этой матрицы путаницы вычисляются два показателя: истинно положительный результат (такой же, как отзыв) и ложноположительный показатель:

Затем выбирается новый, более высокий порог и создается новая матрица неточностей. Используя эту матрицу неточностей, рассчитываются новые TPR и FPR. Этот процесс повторяется для множества различных пороговых значений от 0 до 1, и для каждого порога находятся новые значения TPR и FPR. В конце концов, все TPR и FPR строятся друг против друга:

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

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

Мы получили средний балл по AUROC 0,82.

Оценка ROC AUC и оценка F1 в мультиклассовой классификации

Вкратце, основное различие между ROC AUC и F1 связано с классовым дисбалансом. Вот краткое изложение чтения многих потоков StackOverflow о том, как выбрать один из них:

Если у вас высокий класс дисбаланса, всегда выбирайте оценку F1, потому что высокая оценка F1 учитывает как точность, так и отзывчивость. Чтобы получить высокий F1, как ложных срабатываний, так и ложных отрицательных результатов должно быть мало. С другой стороны, ROC AUC может давать очень высокие баллы при достаточно большом количестве ложных срабатываний. Кроме того, вы также можете рассматривать оценку ROC AUC как среднее значение баллов F1 (как хороших, так и плохих), оцененных на различных порогах. Всегда используйте F1, если у вас дисбаланс классов. Более высокий ROC AUC не обязательно означает лучший классификатор.

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

Оценка F1 против ROC AUC
Как интерпретировать почти идеальную точность и AUC-ROC, но нулевой показатель f1, точность и отзывчивость
Как выбрать между ROC AUC и счетом F1?
В чем разница между AUC и F1-оценкой?

Оценка Коэна по шкале Каппа для мультиклассовой классификации

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

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

В официальной литературе это определение — это «показатель для количественной оценки согласия между двумя оценщиками». Вот определение из Википедии:

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

Вот официальная формула:

В классификации эта формула трактуется следующим образом:

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

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

Давайте сначала определим точность: сумма диагональных ячеек, деленная на сумму недиагональных — 0,6. Чтобы найти значение P_e, нам нужно найти, что вероятности истинных значений такие же, как случайно предсказанные значения для каждого класса.

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

P (actual_ideal) = 57/250 = 0,228

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

P (predicted_ideal) = 16/250 = 0,064

Вероятность того, что оба условия верны, является их результатом:

P_e (фактическая_идеальная, предсказанная_идеальная) = 0,228 * 0,064 = 0,014592

Теперь сделаем то же самое для других классов:

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

P (фактическая_премиум) = 45/250 = 0,18

P (предсказанная_премиум) = 28/250 = 0,112

P_e (actual_premium, predicted_premium) = 0,02016

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

P (фактическое_хорошее) = 74/250 = 0,296

P (предсказано_хорошо) = 26/250 = 0,104

P_e (фактически_хорошо, предсказано_хорошо) = 0,030784

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

P (actual_fair) = 74/250 = 0,296

P (предсказанная_ справедливость) = 30/250 = 0,12

P_e (actual_fair, predicted_fair) = 0,03552

Окончательный P_e — это сумма приведенных выше расчетов:

P_e (окончательный) = 0,014592 + 0,02016 + 0,030784 + 0,03552 = 0,101056

Точность, P_0 = 0,6

Подключаем числа:

Хорошая новость в том, что вы можете сделать все это в строке кода с помощью Sklearn:

Как правило, оценка выше 0,8 считается отличной. Мы получили довольно скромную оценку.

Для получения дополнительной информации я предлагаю прочитать эти две отличные статьи:

Мультиклассовые метрики стали проще, часть III: показатель Каппа (он же коэффициент Каппа Коэна)
Что такое статистика Каппа Коэна?

Коэффициент корреляции Мэтью для мультиклассовой классификации

Встречайте еще одну однозначную альтернативу точности — коэффициент корреляции Мэтью. Я думаю, что это единственная метрика, которую могли бы придумать статистики, которая включает все 4 элемента матрицы и действительно имеет смысл:

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

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

К счастью, Sklearn также включает эту метрику:

Мы получили оценку 0,46, что является умеренно сильной корреляцией. Как правило, хорошие оценки считаются значениями выше 0,7.

Кстати, приведенная выше формула была для бинарных классификаторов. Для мультикласса Sklearn дает еще более чудовищную формулу:

Потеря журнала для мультиклассовой классификации

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

Еще одним преимуществом потери журнала является то, что он работает только с оценками вероятности или, другими словами, с алгоритмами, которые могут генерировать оценки вероятностного членства. Это означает, что эта функция ошибок учитывает неопределенность модели. Например, прогноз класса с баллом 0,9 более надежен, чем прогноз с баллом 0,6. Многие из метрик, которые мы обсуждали сегодня, используют метки прогнозов (например, класс 1, класс 2), которые скрывают неопределенность модели при генерации этих прогнозов, тогда как потеря журнала — нет.

Это сильно наказывает случаи, когда модель предсказывала членство в классе с низкими оценками. Для двоичного случая его формула:

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

Вот несколько ссылок, чтобы укрепить ваше понимание:

Блокнот Kaggle о потерях журнала
Понимание потери журнала прямо из Kaggle
Руководство пользователя Sklearn по потере журнала
Мультиклассовая логарифмическая функция потерь на класс

Резюме

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

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

Сравните общую производительность одного классификатора с другим по единой метрике — используйте коэффициент корреляции Мэтью, каппу Коэна и логарифмические потери.
Оцените способность классификатора различать каждый класс в сбалансированной классификации: оценка ROC AUC.
Показатель, сводящий к минимуму количество ложных срабатываний и ложных срабатываний при несбалансированной классификации: оценка F1.
Сосредоточьтесь на уменьшении количества ложных срабатываний одного класса: Точность для этого класса.
Сосредоточьтесь на уменьшении ложноотрицательных результатов одного класса: Напомним для этого класса.

Вас также может заинтересовать…

Есть 3 различных API для оценки качества прогнозов модели:

Метод оценки оценщика : у оценщиков есть score метод, обеспечивающий критерий оценки по умолчанию для проблемы, для решения которой они предназначены. Это обсуждается не на этой странице, а в документации каждого оценщика.
Параметр оценки: инструменты оценки модели с использованием перекрестной проверки (например, model_selection.cross_val_score и model_selection.GridSearchCV) полагаются на внутреннюю стратегию оценки . Это обсуждается в разделе Параметр оценки: определение правил оценки модели .
Метрические функции : В sklearn.metrics модуле реализованы функции оценки ошибки прогноза для конкретных целей. Эти показатели подробно описаны в разделах по метрикам классификации , MultiLabel ранжирования показателей , показателей регрессии и показателей кластеризации .

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

3.3.1. В scoring параметрах: определение правил оценки моделей

Выбор и оценка модели с использованием таких инструментов, как model_selection.GridSearchCV и model_selection.cross_val_score, принимают scoring параметр, который контролирует, какую метрику они применяют к оцениваемым оценщикам.

3.3.1.1. Общие случаи: предопределенные значения

Для наиболее распространенных случаев использования вы можете назначить объект подсчета с помощью scoring параметра; в таблице ниже показаны все возможные значения. Все объекты счетчика следуют соглашению о том, что более высокие возвращаемые значения лучше, чем более низкие возвращаемые значения . Таким образом, метрики, которые измеряют расстояние между моделью и данными, например metrics.mean_squared_error, доступны как neg_mean_squared_error, которые возвращают инвертированное значение метрики.

Подсчет очков	Функция	Комментарий
Классификация
‘accuracy’	`metrics.accuracy_score`
‘balanced_accuracy’	`metrics.balanced_accuracy_score`
‘top_k_accuracy’	`metrics.top_k_accuracy_score`
‘average_precision’	`metrics.average_precision_score`
‘neg_brier_score’	`metrics.brier_score_loss`
‘f1’	`metrics.f1_score`	для двоичных целей
‘f1_micro’	`metrics.f1_score`	микро-усредненный
‘f1_macro’	`metrics.f1_score`	микро-усредненный
‘f1_weighted’	`metrics.f1_score`	средневзвешенное
‘f1_samples’	`metrics.f1_score`	по многопозиционному образцу
‘neg_log_loss’	`metrics.log_loss`	требуется `predict_proba`поддержка
‘precision’ etc.	`metrics.precision_score`	суффиксы применяются как с ‘f1’
‘recall’ etc.	`metrics.recall_score`	суффиксы применяются как с ‘f1’
‘jaccard’ etc.	`metrics.jaccard_score`	суффиксы применяются как с ‘f1’
‘roc_auc’	`metrics.roc_auc_score`
‘roc_auc_ovr’	`metrics.roc_auc_score`
‘roc_auc_ovo’	`metrics.roc_auc_score`
‘roc_auc_ovr_weighted’	`metrics.roc_auc_score`
‘roc_auc_ovo_weighted’	`metrics.roc_auc_score`
Кластеризация
‘adjusted_mutual_info_score’	`metrics.adjusted_mutual_info_score`
‘adjusted_rand_score’	`metrics.adjusted_rand_score`
‘completeness_score’	`metrics.completeness_score`
‘fowlkes_mallows_score’	`metrics.fowlkes_mallows_score`
‘homogeneity_score’	`metrics.homogeneity_score`
‘mutual_info_score’	`metrics.mutual_info_score`
‘normalized_mutual_info_score’	`metrics.normalized_mutual_info_score`
‘rand_score’	`metrics.rand_score`
‘v_measure_score’	`metrics.v_measure_score`
Регрессия
‘explained_variance’	`metrics.explained_variance_score`
‘max_error’	`metrics.max_error`
‘neg_mean_absolute_error’	`metrics.mean_absolute_error`
‘neg_mean_squared_error’	`metrics.mean_squared_error`
‘neg_root_mean_squared_error’	`metrics.mean_squared_error`
‘neg_mean_squared_log_error’	`metrics.mean_squared_log_error`
‘neg_median_absolute_error’	`metrics.median_absolute_error`
‘r2’	`metrics.r2_score`
‘neg_mean_poisson_deviance’	`metrics.mean_poisson_deviance`
‘neg_mean_gamma_deviance’	`metrics.mean_gamma_deviance`
‘neg_mean_absolute_percentage_error’	`metrics.mean_absolute_percentage_error`

Примеры использования:

>>> from sklearn import svm, datasets
>>> from sklearn.model_selection import cross_val_score
>>> X, y = datasets.load_iris(return_X_y=True)
>>> clf = svm.SVC(random_state=0)
>>> cross_val_score(clf, X, y, cv=5, scoring='recall_macro')
array([0.96..., 0.96..., 0.96..., 0.93..., 1.        ])
>>> model = svm.SVC()
>>> cross_val_score(model, X, y, cv=5, scoring='wrong_choice')
Traceback (most recent call last):
ValueError: 'wrong_choice' is not a valid scoring value. Use sorted(sklearn.metrics.SCORERS.keys()) to get valid options.

Примечание

Значения, перечисленные в виде ValueError исключения, соответствуют функциям измерения точности прогнозирования, описанным в следующих разделах. Объекты счетчика для этих функций хранятся в словаре sklearn.metrics.SCORERS.

3.3.1.2. Определение стратегии выигрыша от метрических функций

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

функции, заканчивающиеся на, _score возвращают значение для максимизации, чем выше, тем лучше.
функции, заканчивающиеся на _error или _loss возвращающие значение, которое нужно минимизировать, чем ниже, тем лучше. При преобразовании в объект счетчика с использованием make_scorer установите для greater_is_better параметра значение False ( True по умолчанию; см. Описание параметра ниже).

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

Многим метрикам не даются имена для использования в качестве scoring значений, иногда потому, что они требуют дополнительных параметров, например fbeta_score. В таких случаях вам необходимо создать соответствующий объект оценки. Самый простой способ создать вызываемый объект для оценки — использовать make_scorer. Эта функция преобразует метрики в вызываемые объекты, которые можно использовать для оценки модели.

Один из типичных вариантов использования — обернуть существующую метрическую функцию из библиотеки значениями, отличными от значений по умолчанию для ее параметров, такими как beta параметр для fbeta_score функции:

>>> from sklearn.metrics import fbeta_score, make_scorer
>>> ftwo_scorer = make_scorer(fbeta_score, beta=2)
>>> from sklearn.model_selection import GridSearchCV
>>> from sklearn.svm import LinearSVC
>>> grid = GridSearchCV(LinearSVC(), param_grid={'C': [1, 10]},
...                     scoring=ftwo_scorer, cv=5)

Второй вариант использования — создание полностью настраиваемого объекта скоринга из простой функции Python с использованием make_scorer, которая может принимать несколько параметров:

функция Python, которую вы хотите использовать ( my_custom_loss_func в примере ниже)
возвращает ли функция Python оценку ( greater_is_better=True, по умолчанию) или потерю ( greater_is_better=False). В случае потери результат функции python аннулируется объектом скоринга в соответствии с соглашением о перекрестной проверке, согласно которому скоринтеры возвращают более высокие значения для лучших моделей.
только для показателей классификации: требуется ли для предоставленной вами функции Python постоянная уверенность в принятии решений ( needs_threshold=True). Значение по умолчанию неверно.
любые дополнительные параметры, такие как betaили labels в f1_score.

Вот пример создания пользовательских счетчиков очков и использования greater_is_better параметра:

>>> import numpy as np
>>> def my_custom_loss_func(y_true, y_pred):
...     diff = np.abs(y_true - y_pred).max()
...     return np.log1p(diff)
...
>>> # score will negate the return value of my_custom_loss_func,
>>> # which will be np.log(2), 0.693, given the values for X
>>> # and y defined below.
>>> score = make_scorer(my_custom_loss_func, greater_is_better=False)
>>> X = [[1], [1]]
>>> y = [0, 1]
>>> from sklearn.dummy import DummyClassifier
>>> clf = DummyClassifier(strategy='most_frequent', random_state=0)
>>> clf = clf.fit(X, y)
>>> my_custom_loss_func(y, clf.predict(X))
0.69...
>>> score(clf, X, y)
-0.69...

3.3.1.3. Реализация собственного скорингового объекта

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

Его можно вызвать с параметрами (estimator, X, y), где estimator это модель, которая должна быть оценена, X это данные проверки и y основная истинная цель для (в контролируемом случае) или None (в неконтролируемом случае).
Он возвращает число с плавающей запятой, которое количественно определяет estimator качество прогнозирования X со ссылкой на y. Опять же, по соглашению более высокие числа лучше, поэтому, если ваш секретарь сообщает о проигрыше, это значение следует отменить.

Примечание Использование пользовательских счетчиков в функциях, где n_jobs> 1

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

Например, чтобы использовать n_jobsбольше 1 в примере ниже, custom_scoring_function функция сохраняется в созданном пользователем модуле ( custom_scorer_module.py) и импортируется:

>>> from custom_scorer_module import custom_scoring_function 
>>> cross_val_score(model,
...  X_train,
...  y_train,
...  scoring=make_scorer(custom_scoring_function, greater_is_better=False),
...  cv=5,
...  n_jobs=-1)

3.3.1.4. Использование множественной метрической оценки

Scikit-learn также позволяет оценивать несколько показателей в GridSearchCV, RandomizedSearchCV и cross_validate.

Есть три способа указать несколько показателей оценки для scoring параметра:

Как итерация строковых показателей:

>>> scoring = ['accuracy', 'precision']

В качестве dictсопоставления имени секретаря с функцией подсчета очков:

>>> from sklearn.metrics import accuracy_score
>>> from sklearn.metrics import make_scorer
>>> scoring = {'accuracy': make_scorer(accuracy_score),
...            'prec': 'precision'}

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

Как вызываемый объект, возвращающий словарь оценок:

>>> from sklearn.model_selection import cross_validate
>>> from sklearn.metrics import confusion_matrix
>>> # A sample toy binary classification dataset
>>> X, y = datasets.make_classification(n_classes=2, random_state=0)
>>> svm = LinearSVC(random_state=0)
>>> def confusion_matrix_scorer(clf, X, y):
...      y_pred = clf.predict(X)
...      cm = confusion_matrix(y, y_pred)
...      return {'tn': cm[0, 0], 'fp': cm[0, 1],
...              'fn': cm[1, 0], 'tp': cm[1, 1]}
>>> cv_results = cross_validate(svm, X, y, cv=5,
...                             scoring=confusion_matrix_scorer)
>>> # Getting the test set true positive scores
>>> print(cv_results['test_tp'])
[10  9  8  7  8]
>>> # Getting the test set false negative scores
>>> print(cv_results['test_fn'])
[0 1 2 3 2]

3.3.2. Метрики классификации

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

Некоторые из них ограничены случаем двоичной классификации:

`precision_recall_curve`(y_true, probas_pred, *)	Вычислите пары точности-отзыва для разных пороговых значений вероятности.
`roc_curve`(y_true, y_score, *[, pos_label, …])	Вычислить рабочую характеристику приемника (ROC).
`det_curve`(y_true, y_score[, pos_label, …])	Вычислите частоту ошибок для различных пороговых значений вероятности.

Другие также работают в случае мультикласса:

`balanced_accuracy_score`(y_true, y_pred, *[, …])	Вычислите сбалансированную точность.
`cohen_kappa_score`(y1, y2, *[, labels, …])	Каппа Коэна: статистика, измеряющая согласованность аннотаторов.
`confusion_matrix`(y_true, y_pred, *[, …])	Вычислите матрицу неточностей, чтобы оценить точность классификации.
`hinge_loss`(y_true, pred_decision, *[, …])	Средняя потеря петель (нерегулируемая).
`matthews_corrcoef`(y_true, y_pred, *[, …])	Вычислите коэффициент корреляции Мэтьюза (MCC).
`roc_auc_score`(y_true, y_score, *[, average, …])	Вычислить площадь под кривой рабочих характеристик приемника (ROC AUC) по оценкам прогнозов.
`top_k_accuracy_score`(y_true, y_score, *[, …])	Top-k Рейтинг по классификации точности.

Некоторые также работают в многоярусном регистре:

`accuracy_score`(y_true, y_pred, *[, …])	Классификационная оценка точности.
`classification_report`(y_true, y_pred, *[, …])	Создайте текстовый отчет, показывающий основные показатели классификации.
`f1_score`(y_true, y_pred, *[, labels, …])	Вычислите оценку F1, также известную как сбалансированная оценка F или F-мера.
`fbeta_score`(y_true, y_pred, *, beta[, …])	Вычислите оценку F-beta.
`hamming_loss`(y_true, y_pred, *[, sample_weight])	Вычислите среднюю потерю Хэмминга.
`jaccard_score`(y_true, y_pred, *[, labels, …])	Оценка коэффициента сходства Жаккара.
`log_loss`(y_true, y_pred, *[, eps, …])	Потеря журнала, также известная как потеря логистики или потеря кросс-энтропии.
`multilabel_confusion_matrix`(y_true, y_pred, *)	Вычислите матрицу неточностей для каждого класса или образца.
`precision_recall_fscore_support`(y_true, …)	Точность вычислений, отзыв, F-мера и поддержка для каждого класса.
`precision_score`(y_true, y_pred, *[, labels, …])	Вычислите точность.
`recall_score`(y_true, y_pred, *[, labels, …])	Вычислите отзыв.
`roc_auc_score`(y_true, y_score, *[, average, …])	Вычислить площадь под кривой рабочих характеристик приемника (ROC AUC) по оценкам прогнозов.
`zero_one_loss`(y_true, y_pred, *[, …])	Потеря классификации нулевая единица.

А некоторые работают с двоичными и многозначными (но не мультиклассовыми) проблемами:

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

3.3.2.1. От бинарного до мультиклассового и многозначного

Некоторые метрики по существу определены для задач двоичной классификации (например f1_score, roc_auc_score). В этих случаях по умолчанию оценивается только положительная метка, предполагая по умолчанию, что положительный класс помечен 1 (хотя это можно настроить с помощью pos_label параметра).

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

"macro" просто вычисляет среднее значение двоичных показателей, придавая каждому классу одинаковый вес. В задачах, где редкие занятия тем не менее важны, макро-усреднение может быть средством выделения их производительности. С другой стороны, предположение, что все классы одинаково важны, часто неверно, так что макро-усреднение будет чрезмерно подчеркивать обычно низкую производительность для нечастого класса.
"weighted" учитывает дисбаланс классов, вычисляя среднее значение двоичных показателей, в которых оценка каждого класса взвешивается по его присутствию в истинной выборке данных.
"micro" дает каждой паре выборка-класс равный вклад в общую метрику (за исключением результата взвешивания выборки). Вместо того, чтобы суммировать метрику для каждого класса, это суммирует дивиденды и делители, составляющие метрики для каждого класса, для расчета общего частного. Микро-усреднение может быть предпочтительным в настройках с несколькими ярлыками, включая многоклассовую классификацию, когда класс большинства следует игнорировать.
"samples" применяется только к задачам с несколькими ярлыками. Он не вычисляет меру для каждого класса, вместо этого вычисляет метрику по истинным и прогнозируемым классам для каждой выборки в данных оценки и возвращает их ( sample_weight — взвешенное) среднее значение.
Выбор average=None вернет массив с оценкой для каждого класса.

В то время как данные мультикласса предоставляются метрике, как двоичные цели, в виде массива меток классов, данные с несколькими метками указываются как индикаторная матрица, в которой ячейка [i, j] имеет значение 1, если у образца i есть метка j, и значение 0 в противном случае.

3.3.2.2. Оценка точности

Функция accuracy_score вычисляет точность , либо фракции ( по умолчанию) или количество (нормализует = False) правильных предсказаний.

В классификации с несколькими ярлыками функция возвращает точность подмножества. Если весь набор предсказанных меток для выборки строго соответствует истинному набору меток, то точность подмножества равна 1,0; в противном случае — 0, 0.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ — соответствующее истинное значение, тогда доля правильных прогнозов по сравнению с $n_{samples}$ определяется как
$$texttt{accuracy}(y, hat{y}) = frac{1}{n_text{samples}} sum_{i=0}^{n_text{samples}-1} 1(hat{y}_i = y_i)$$

где $1(x)$- индикаторная функция .

>>> import numpy as np
>>> from sklearn.metrics import accuracy_score
>>> y_pred = [0, 2, 1, 3]
>>> y_true = [0, 1, 2, 3]
>>> accuracy_score(y_true, y_pred)
0.5
>>> accuracy_score(y_true, y_pred, normalize=False)
2

В многопозиционном корпусе с бинарными индикаторами меток:

>>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

Пример:

См. В разделе Проверка с перестановками значимости классификационной оценки пример использования показателя точности с использованием перестановок набора данных.

3.3.2.3. Рейтинг точности Top-k

Функция top_k_accuracy_score представляет собой обобщение accuracy_score. Разница в том, что прогноз считается правильным, если истинная метка связана с одним из kнаивысших прогнозируемых баллов. accuracy_score является частным случаем k = 1.

Функция охватывает случаи двоичной и многоклассовой классификации, но не случай многозначной классификации.

Если $hat{f}_{i,j}$ прогнозируемый класс для $i$-й образец, соответствующий $j$-й по величине прогнозируемый результат и $y_i$ — соответствующее истинное значение, тогда доля правильных прогнозов по сравнению с $n_{samples}$ определяется как
$$texttt{top-k accuracy}(y, hat{f}) = frac{1}{n_text{samples}} sum_{i=0}^{n_text{samples}-1} sum_{j=1}^{k} 1(hat{f}_{i,j} = y_i)$$

где k допустимое количество предположений и 1(x)- индикаторная функция.

>>> import numpy as np
>>> from sklearn.metrics import top_k_accuracy_score
>>> y_true = np.array([0, 1, 2, 2])
>>> y_score = np.array([[0.5, 0.2, 0.2],
...                     [0.3, 0.4, 0.2],
...                     [0.2, 0.4, 0.3],
...                     [0.7, 0.2, 0.1]])
>>> top_k_accuracy_score(y_true, y_score, k=2)
0.75
>>> # Not normalizing gives the number of "correctly" classified samples
>>> top_k_accuracy_score(y_true, y_score, k=2, normalize=False)
3

3.3.2.4. Сбалансированный показатель точности

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

В двоичном случае сбалансированная точность равна среднему арифметическому чувствительности (истинно положительный показатель) и специфичности (истинно отрицательный показатель) или площади под кривой ROC с двоичными прогнозами, а не баллами:
$$texttt{balanced-accuracy} = frac{1}{2}left( frac{TP}{TP + FN} + frac{TN}{TN + FP}right )$$

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

Напротив, если обычная точность выше вероятности только потому, что классификатор использует несбалансированный набор тестов, тогда сбалансированная точность, при необходимости, упадет до $frac{1}{n_classes}$.

Оценка варьируется от 0 до 1 или, когда adjusted=True используется, масштабируется до диапазона $frac{1}{1 — n_classes}$ до 1 включительно, с произвольной оценкой 0.

Если yi истинная ценность $i$-й образец, и $w_i$ — соответствующий вес образца, затем мы настраиваем вес образца на:
$$hat{w}_i = frac{w_i}{sum_j{1(y_j = y_i) w_j}}$$

где $1(x)$- индикаторная функция . Учитывая предсказанный $hat{y}_i$ для образца $i$, сбалансированная точность определяется как:
$$texttt{balanced-accuracy}(y, hat{y}, w) = frac{1}{sum{hat{w}_i}} sum_i 1(hat{y}_i = y_i) hat{w}_i$$

С adjusted=True сбалансированной точностью сообщает об относительном увеличении от $texttt{balanced-accuracy}(y, mathbf{0}, w) =frac{1}{n_classes}$. В двоичном случае это также известно как * статистика Юдена * , или информированность .

Примечание

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

Наше определение: [Mosley2013] , [Kelleher2015] и [Guyon2015] , где [Guyon2015] принимает скорректированную версию, чтобы гарантировать, что случайные предсказания имеют оценку 0 а точные предсказания имеют оценку 1..
Точность балансировки классов, как описано в [Mosley2013] : вычисляется минимум между точностью и отзывом для каждого класса. Затем эти значения усредняются по общему количеству классов для получения сбалансированной точности.
Сбалансированная точность, как описано в [Urbanowicz2015] : среднее значение чувствительности и специфичности вычисляется для каждого класса, а затем усредняется по общему количеству классов.

Рекомендации:

Гийон 2015 ( 1 , 2 ) И. Гайон, К. Беннет, Г. Коули, Х. Дж. Эскаланте, С. Эскалера, Т. К. Хо, Н. Масиа, Б. Рэй, М. Саид, А. Р. Статников, Э. Вьегас, Дизайн конкурса ChaLearn AutoML Challenge 2015 , IJCNN 2015 г.
Мосли 2013 ( 1 , 2 ) Л. Мосли, Сбалансированный подход к проблеме мультиклассового дисбаланса , IJCV 2010.
Kelleher2015 Джон. Д. Келлехер, Брайан Мак Нейме, Аойф Д’Арси, Основы машинного обучения для прогнозной аналитики данных: алгоритмы, рабочие примеры и тематические исследования , 2015.
Урбанович2015 Urbanowicz RJ, Moore, JH ExSTraCS 2.0: описание и оценка масштабируемой системы классификаторов обучения , Evol. Intel. (2015) 8:89.

3.3.2.5. Каппа Коэна

Функция cohen_kappa_score вычисляет каппа-Коэна статистику. Эта мера предназначена для сравнения меток, сделанных разными людьми-аннотаторами, а не классификатором с достоверной информацией.

Показатель каппа (см. Строку документации) представляет собой число от -1 до 1. Баллы выше 0,8 обычно считаются хорошим совпадением; ноль или ниже означает отсутствие согласия (практически случайные метки).

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

>>> from sklearn.metrics import cohen_kappa_score
>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> cohen_kappa_score(y_true, y_pred)
0.4285714285714286

3.3.2.6. Матрица неточностей ¶

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

По определению запись i,j в матрице неточностей — количество наблюдений в группе i, но предполагается, что он будет в группе j. Вот пример:

>>> from sklearn.metrics import confusion_matrix
>>> y_true = [2, 0, 2, 2, 0, 1]
>>> y_pred = [0, 0, 2, 2, 0, 2]
>>> confusion_matrix(y_true, y_pred)
array([[2, 0, 0],
       [0, 0, 1],
       [1, 0, 2]])

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

Параметр normalize позволяет сообщать коэффициенты вместо подсчетов. Матрица путаница может быть нормализована в 3 различными способами: 'pred', 'true'и 'all' которые будут делить счетчики на сумму каждого столбца, строки или всей матрицы, соответственно.

>>> y_true = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> confusion_matrix(y_true, y_pred, normalize='all')
array([[0.25 , 0.125],
       [0.25 , 0.375]])

Для двоичных задач мы можем получить подсчет истинно отрицательных, ложноположительных, ложноотрицательных и истинно положительных результатов следующим образом:

>>> y_true = [0, 0, 0, 1, 1, 1, 1, 1]
>>> y_pred = [0, 1, 0, 1, 0, 1, 0, 1]
>>> tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
>>> tn, fp, fn, tp
(2, 1, 2, 3)

Пример:

См. В разделе Матрица неточностей пример использования матрицы неточностей для оценки качества выходных данных классификатора.
См. В разделе Распознавание рукописных цифр пример использования матрицы неточностей для классификации рукописных цифр.
См. Раздел Классификация текстовых документов с использованием разреженных функций для примера использования матрицы неточностей для классификации текстовых документов.

3.3.2.7. Отчет о классификации

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

>>> from sklearn.metrics import classification_report
>>> y_true = [0, 1, 2, 2, 0]
>>> y_pred = [0, 0, 2, 1, 0]
>>> target_names = ['class 0', 'class 1', 'class 2']
>>> print(classification_report(y_true, y_pred, target_names=target_names))
              precision    recall  f1-score   support

     class 0       0.67      1.00      0.80         2
     class 1       0.00      0.00      0.00         1
     class 2       1.00      0.50      0.67         2

    accuracy                           0.60         5
   macro avg       0.56      0.50      0.49         5
weighted avg       0.67      0.60      0.59         5

Пример:

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

3.3.2.8. Потеря Хэмминга

hamming_loss вычисляет среднюю потерю Хэмминга или расстояние Хемминга между двумя наборами образцов.

Если $hat{y}_j$ прогнозируемое значение для $j$-я этикетка данного образца, $y_j$ — соответствующее истинное значение, а $n_{labels}$ — количество классов или меток, то потеря Хэмминга $L_{Hamming}$ между двумя образцами определяется как:
$$L_{Hamming}(y, hat{y}) = frac{1}{n_text{labels}} sum_{j=0}^{n_text{labels} — 1} 1(hat{y}_j not= y_j)$$

где $1(x)$- индикаторная функция .

>>> from sklearn.metrics import hamming_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> hamming_loss(y_true, y_pred)
0.25

В многопозиционном корпусе с бинарными индикаторами меток:

>>> hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2)))
0.75

Примечание

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

3.3.2.9. Точность, отзыв и F-меры

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

F-мера ($F_beta$ а также $F_1$ меры) можно интерпретировать как взвешенное гармоническое среднее значение точности и полноты. А $F_beta$ мера достигает своего лучшего значения на уровне 1 и худшего результата на уровне 0. С $beta = 1$, $F_beta$ а также $F_1$ эквивалентны, а отзыв и точность одинаково важны.

precision_recall_curve вычисляет кривую точности-отзыва на основе наземной метки истинности и оценки, полученной классификатором путем изменения порога принятия решения.

Функция average_precision_score вычисляет среднюю точность (AP) от оценки прогнозирования. Значение от 0 до 1 и выше — лучше. AP определяется как
$$text{AP} = sum_n (R_n — R_{n-1}) P_n$$

где $P_n$ а также $R_n$- точность и отзыв на n-м пороге. При случайных прогнозах AP — это доля положительных образцов.

Ссылки [Manning2008] и [Everingham2010] представляют альтернативные варианты AP, которые интерполируют кривую точности-отзыва. В настоящее время average_precision_score не реализован какой-либо вариант с интерполяцией. Ссылки [Davis2006] и [Flach2015] описывают, почему линейная интерполяция точек на кривой точности-отзыва обеспечивает чрезмерно оптимистичный показатель эффективности классификатора. Эта линейная интерполяция используется при вычислении площади под кривой с помощью правила трапеции в auc.

Несколько функций позволяют анализировать точность, отзыв и оценку F-мер:

`average_precision_score`(y_true, y_score, *)	Вычислить среднюю точность (AP) из оценок прогнозов.
`f1_score`(y_true, y_pred, *[, labels, …])	Вычислите оценку F1, также известную как сбалансированная оценка F или F-мера.
`fbeta_score`(y_true, y_pred, *, beta[, …])	Вычислите оценку F-beta.
`precision_recall_curve`(y_true, probas_pred, *)	Вычислите пары точности-отзыва для разных пороговых значений вероятности.
`precision_recall_fscore_support`(y_true, …)	Точность вычислений, отзыв, F-мера и поддержка для каждого класса.
`precision_score`(y_true, y_pred, *[, labels, …])	Вычислите точность.
`recall_score`(y_true, y_pred, *[, labels, …])	Вычислите рекол.

Обратите внимание, что функция precision_recall_curve ограничена двоичным регистром. Функция average_precision_score работает только в двоичном формате классификации и MultiLabel индикатора. В функции plot_precision_recall_curve графики точности вспомнить следующим образом .

Примеры:

См. Раздел Классификация текстовых документов с использованием разреженных функций для примера использования f1_score для классификации текстовых документов.
См. Раздел « Оценка параметров с использованием поиска по сетке с перекрестной проверкой», где приведен пример precision_score и recall_score использование для оценки параметров с помощью поиска по сетке с вложенной перекрестной проверкой.
См. В разделе Precision-Recall пример использования precision_recall_curve для оценки качества вывода классификатора.

Рекомендации:

[Manning2008] г. CD Manning, P. Raghavan, H. Schütze, Introduction to Information Retrieval , 2008.
[Everingham2010] М. Эверингем, Л. Ван Гул, CKI Уильямс, Дж. Винн, А. Зиссерман, Задача классов визуальных объектов Pascal (VOC) , IJCV 2010.
[Davis2006] Дж. Дэвис, М. Гоадрич, Взаимосвязь между точным воспроизведением и кривыми ROC , ICML 2006.
[Flach2015] П.А. Флэч, М. Кулл, Кривые точности-отзыва-выигрыша: PR-анализ выполнен правильно , NIPS 2015.

3.3.2.9.1. Бинарная классификация

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

	Фактический класс (наблюдение)
Прогнозируемый класс (ожидание)	tp (истинно положительный результат) Правильный результат	fp (ложное срабатывание) Неожиданный результат
Прогнозируемый класс (ожидание)	fn (ложноотрицательный) Отсутствует результат	tn (истинно отрицательное) Правильное отсутствие результата

В этом контексте мы можем определить понятия точности, отзыва и F-меры:
$$text{precision} = frac{tp}{tp + fp},$$
$$text{recall} = frac{tp}{tp + fn},$$
$$F_beta = (1 + beta^2) frac{text{precision} times text{recall}}{beta^2 text{precision} + text{recall}}.$$

Вот несколько небольших примеров бинарной классификации:

>>> from sklearn import metrics
>>> y_pred = [0, 1, 0, 0]
>>> y_true = [0, 1, 0, 1]
>>> metrics.precision_score(y_true, y_pred)
1.0
>>> metrics.recall_score(y_true, y_pred)
0.5
>>> metrics.f1_score(y_true, y_pred)
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=0.5)
0.83...
>>> metrics.fbeta_score(y_true, y_pred, beta=1)
0.66...
>>> metrics.fbeta_score(y_true, y_pred, beta=2)
0.55...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5)
(array([0.66..., 1.        ]), array([1. , 0.5]), array([0.71..., 0.83...]), array([2, 2]))


>>> import numpy as np
>>> from sklearn.metrics import precision_recall_curve
>>> from sklearn.metrics import average_precision_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, threshold = precision_recall_curve(y_true, y_scores)
>>> precision
array([0.66..., 0.5       , 1.        , 1.        ])
>>> recall
array([1. , 0.5, 0.5, 0. ])
>>> threshold
array([0.35, 0.4 , 0.8 ])
>>> average_precision_score(y_true, y_scores)
0.83...

3.3.2.9.2. Мультиклассовая и многозначная классификация

В задаче классификации по нескольким классам и меткам понятия точности, отзыва и F-меры могут применяться к каждой метке независимо. Есть несколько способов , чтобы объединить результаты по этикеткам, указанных в average аргументе к average_precision_score (MultiLabel только) f1_score, fbeta_score, precision_recall_fscore_support, precision_score и recall_score функция, как описано выше . Обратите внимание, что если включены все метки, «микро» -усреднение в настройке мультикласса обеспечит точность, отзыв и $F$ все они идентичны по точности. Также обратите внимание, что «взвешенное» усреднение может дать оценку F, которая не находится между точностью и отзывом.

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

$y$ набор предсказанных ($sample$, $label$) пары
$hat{y}$ набор истинных ($sample$, $label$) пары
$L$ набор лейблов
$S$ набор образцов
$y_s$ подмножество $y$ с образцом $s$, т.е $y_s := left{(s’, l) in y | s’ = sright}$.
$y_l$ подмножество $y$ с этикеткой $l$
по аналогии, $hat{y}_s$ а также $hat{y}_l$ являются подмножествами $hat{y}$
$P(A, B) := frac{left| A cap B right|}{left|Aright|}$ для некоторых наборов $A$ и $B$
$R(A, B) := frac{left| A cap B right|}{left|Bright|}$ (Условные обозначения различаются в зависимости от обращения $B = emptyset$; эта реализация использует $R(A, B):=0$, и аналогичные для $P$.)
$$F_beta(A, B) := left(1 + beta^2right) frac{P(A, B) times R(A, B)}{beta^2 P(A, B) + R(A, B)}$$

Тогда показатели определяются как:

average	Точность	Отзывать	F_beta
«micro»	$P(y, hat{y})$	$R(y, hat{y})$	$F_beta(y, hat{y})$
«samples»	$frac{1}{left\|Sright\|} sum_{s in S} P(y_s, hat{y}_s)$	$frac{1}{left\|Sright\|} sum_{s in S} R(y_s, hat{y}_s)$	$frac{1}{left\|Sright\|} sum_{s in S} F_beta(y_s, hat{y}_s)$
«macro»	$frac{1}{left\|Lright\|} sum_{l in L} P(y_l, hat{y}_l)$	$frac{1}{left\|Lright\|} sum_{l in L} R(y_l, hat{y}_l)$	$frac{1}{left\|Lright\|} sum_{l in L} F_beta(y_l, hat{y}_l)$
«weighted»	$frac{1}{sum_{l in L} left\|hat{y}lright\|} sum{l in L} left\|hat{y}_lright\| P(y_l, hat{y}_l)$	$frac{1}{sum_{l in L} left\|hat{y}lright\|} sum{l in L} left\|hat{y}_lright\| R(y_l, hat{y}_l)$	$frac{1}{sum_{l in L} left\|hat{y}lright\|} sum{l in L} left\|hat{y}lright\| Fbeta(y_l, hat{y}_l)$
None	$langle P(y_l, hat{y}_l) \| l in L rangle$	$langle R(y_l, hat{y}_l) \| l in L rangle$	$langle F_beta(y_l, hat{y}_l) \| l in L rangle$

>>> from sklearn import metrics
>>> y_true = [0, 1, 2, 0, 1, 2]
>>> y_pred = [0, 2, 1, 0, 0, 1]
>>> metrics.precision_score(y_true, y_pred, average='macro')
0.22...
>>> metrics.recall_score(y_true, y_pred, average='micro')
0.33...
>>> metrics.f1_score(y_true, y_pred, average='weighted')
0.26...
>>> metrics.fbeta_score(y_true, y_pred, average='macro', beta=0.5)
0.23...
>>> metrics.precision_recall_fscore_support(y_true, y_pred, beta=0.5, average=None)
(array([0.66..., 0.        , 0.        ]), array([1., 0., 0.]), array([0.71..., 0.        , 0.        ]), array([2, 2, 2]...))

Для мультиклассовой классификации с «отрицательным классом» можно исключить некоторые метки:

>>> metrics.recall_score(y_true, y_pred, labels=[1, 2], average='micro')
... # excluding 0, no labels were correctly recalled
0.0

Точно так же метки, отсутствующие в выборке данных, могут учитываться при макро-усреднении.

>>> metrics.precision_score(y_true, y_pred, labels=[0, 1, 2, 3], average='macro')
0.166...

3.3.2.10. Оценка коэффициента сходства Жаккара

Функция jaccard_score вычисляет среднее значение коэффициентов сходства Jaccard , также называемый индексом Jaccard, между парами множеств меток.

Коэффициент подобия Жаккара i-ые образцы, с набором меток наземной достоверности yi и прогнозируемый набор меток y^i, определяется как
$$J(y_i, hat{y}_i) = frac{|y_i cap hat{y}_i|}{|y_i cup hat{y}_i|}.$$

jaccard_score работает как precision_recall_fscore_support наивно установленная мера, применяемая изначально к бинарным целям, и расширена для применения к множественным меткам и мультиклассам за счет использования average(см. выше ).

В двоичном случае:

>>> import numpy as np
>>> from sklearn.metrics import jaccard_score
>>> y_true = np.array([[0, 1, 1],
...                    [1, 1, 0]])
>>> y_pred = np.array([[1, 1, 1],
...                    [1, 0, 0]])
>>> jaccard_score(y_true[0], y_pred[0])
0.6666...

В многопозиционном корпусе с бинарными индикаторами меток:

>>> jaccard_score(y_true, y_pred, average='samples')
0.5833...
>>> jaccard_score(y_true, y_pred, average='macro')
0.6666...
>>> jaccard_score(y_true, y_pred, average=None)
array([0.5, 0.5, 1. ])

Задачи с несколькими классами преобразуются в двоичную форму и обрабатываются как соответствующая задача с несколькими метками:

>>> y_pred = [0, 2, 1, 2]
>>> y_true = [0, 1, 2, 2]
>>> jaccard_score(y_true, y_pred, average=None)
array([1. , 0. , 0.33...])
>>> jaccard_score(y_true, y_pred, average='macro')
0.44...
>>> jaccard_score(y_true, y_pred, average='micro')
0.33...

3.3.2.11. Петля лосс

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

Если метки закодированы с помощью +1 и -1, $y$: истинное значение, а $w$ — прогнозируемые решения на выходе decision_function, тогда потери на шарнирах определяются как:
$$L_text{Hinge}(y, w) = maxleft{1 — wy, 0right} = left|1 — wyright|_+$$

Если имеется более двух ярлыков, hinge_loss используется мультиклассовый вариант, разработанный Crammer & Singer. Вот статья, описывающая это.

Если $y_w$ прогнозируемое решение для истинного лейбла и $y_t$ — это максимум предсказанных решений для всех других меток, где предсказанные решения выводятся функцией принятия решений, тогда потеря шарнира в нескольких классах определяется следующим образом:
$$L_text{Hinge}(y_w, y_t) = maxleft{1 + y_t — y_w, 0right}$$

Вот небольшой пример, демонстрирующий использование hinge_loss функции с классификатором svm в задаче двоичного класса:

>>> from sklearn import svm
>>> from sklearn.metrics import hinge_loss
>>> X = [[0], [1]]
>>> y = [-1, 1]
>>> est = svm.LinearSVC(random_state=0)
>>> est.fit(X, y)
LinearSVC(random_state=0)
>>> pred_decision = est.decision_function([[-2], [3], [0.5]])
>>> pred_decision
array([-2.18...,  2.36...,  0.09...])
>>> hinge_loss([-1, 1, 1], pred_decision)
0.3...

Вот пример, демонстрирующий использование hinge_loss функции с классификатором svm в мультиклассовой задаче:

>>> X = np.array([[0], [1], [2], [3]])
>>> Y = np.array([0, 1, 2, 3])
>>> labels = np.array([0, 1, 2, 3])
>>> est = svm.LinearSVC()
>>> est.fit(X, Y)
LinearSVC()
>>> pred_decision = est.decision_function([[-1], [2], [3]])
>>> y_true = [0, 2, 3]
>>> hinge_loss(y_true, pred_decision, labels)
0.56...

3.3.2.12. Лог лосс

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

Для двоичной классификации с истинной меткой $y in {0,1}$ и оценка вероятности $p = operatorname{Pr}(y = 1)$, логарифмическая потеря на выборку представляет собой отрицательную логарифмическую вероятность классификатора с истинной меткой:
$$L_{log}(y, p) = -log operatorname{Pr}(y|p) = -(y log (p) + (1 — y) log (1 — p))$$

Это распространяется на случай мультикласса следующим образом. Пусть истинные метки для набора выборок будут закодированы размером 1 из K как двоичная индикаторная матрица $Y$, т.е. $y_{i,k}=1$ если образец $i$ есть ярлык $k$ взят из набора $K$ этикетки. Пусть $P$ — матрица оценок вероятностей, с $p_{i,k} = operatorname{Pr}(y_{i,k} = 1)$. Тогда потеря журнала всего набора равна
$$L_{log}(Y, P) = -log operatorname{Pr}(Y|P) = — frac{1}{N} sum_{i=0}^{N-1} sum_{k=0}^{K-1} y_{i,k} log p_{i,k}$$

Чтобы увидеть, как это обобщает приведенную выше потерю двоичного журнала, обратите внимание, что в двоичном случае $p_{i,0} = 1 — p_{i,1}$ и $y_{i,0} = 1 — y_{i,1}$, поэтому разложив внутреннюю сумму на $y_{i,k} in {0,1}$ дает двоичную потерю журнала.

В log_loss функции вычисляет журнал потеря дана список меток приземной истины и матриц вероятностей, возвращенный оценщик predict_proba методом.

>>> from sklearn.metrics import log_loss
>>> y_true = [0, 0, 1, 1]
>>> y_pred = [[.9, .1], [.8, .2], [.3, .7], [.01, .99]]
>>> log_loss(y_true, y_pred)
0.1738...

Первое [.9, .1] в y_pred означает 90% вероятность того, что первая выборка будет иметь метку 0. Лог лос неотрицательны.

3.3.2.13. Коэффициент корреляции Мэтьюза

Функция matthews_corrcoef вычисляет коэффициент корреляции Матфея (MCC) для двоичных классов. Цитата из Википедии:

«Коэффициент корреляции Мэтьюза используется в машинном обучении как мера качества двоичных (двухклассных) классификаций. Он учитывает истинные и ложные положительные и отрицательные результаты и обычно рассматривается как сбалансированная мера, которую можно использовать, даже если классы очень разных размеров. MCC — это, по сути, значение коэффициента корреляции между -1 и +1. Коэффициент +1 представляет собой идеальное предсказание, 0 — среднее случайное предсказание и -1 — обратное предсказание. Статистика также известна как коэффициент фи ».

В бинарном (двухклассовом) случае $tp$, $tn$, $fp$ а также $fn$ являются соответственно количеством истинно положительных, истинно отрицательных, ложноположительных и ложноотрицательных результатов, MCC определяется как
$$MCC = frac{tp times tn — fp times fn}{sqrt{(tp + fp)(tp + fn)(tn + fp)(tn + fn)}}.$$

В случае мультикласса коэффициент корреляции Мэтьюза может быть определен в терминах confusion_matrix C для Kклассы. Чтобы упростить определение, рассмотрим следующие промежуточные переменные:

$t_k=sum_{i}^{K} C_{ik}$ количество занятий k действительно произошло,
$p_k=sum_{i}^{K} C_{ki}$ количество занятий k был предсказан,
$c=sum_{k}^{K} C_{kk}$ общее количество правильно спрогнозированных образцов,
$s=sum_{i}^{K} sum_{j}^{K} C_{ij}$ общее количество образцов.

Тогда мультиклассовый MCC определяется как:
$$MCC = frac{ c times s — sum_{k}^{K} p_k times t_k }{sqrt{ (s^2 — sum_{k}^{K} p_k^2) times (s^2 — sum_{k}^{K} t_k^2) }}$$

Когда имеется более двух меток, значение MCC больше не будет находиться в диапазоне от -1 до +1. Вместо этого минимальное значение будет где-то между -1 и 0 в зависимости от количества и распределения наземных истинных меток. Максимальное значение всегда +1.

Вот небольшой пример, иллюстрирующий использование matthews_corrcoef функции:

>>> from sklearn.metrics import matthews_corrcoef
>>> y_true = [+1, +1, +1, -1]
>>> y_pred = [+1, -1, +1, +1]
>>> matthews_corrcoef(y_true, y_pred)
-0.33...

3.3.2.14. Матрица путаницы с несколькими метками

Функция multilabel_confusion_matrix вычисляет класс-накрест ( по умолчанию) или samplewise (samplewise = True) MultiLabel матрицы спутанности для оценки точности классификации. Multilabel_confusion_matrix также обрабатывает данные мультикласса, как если бы они были многоклассовыми, поскольку это преобразование, обычно применяемое для оценки проблем мультикласса с метриками двоичной классификации (такими как точность, отзыв и т. д.).

При вычислении классовой матрицы путаницы с несколькими метками $C$, количество истинных негативов для класса i является $C_{i,0,0}$, ложноотрицательные $C_{i,1,0}$, истинные положительные стороны $C_{i,1,1}$ а ложные срабатывания $C_{i,0,1}$.

Вот пример, демонстрирующий использование multilabel_confusion_matrix функции с вводом многозначной индикаторной матрицы:

>>> import numpy as np
>>> from sklearn.metrics import multilabel_confusion_matrix
>>> y_true = np.array([[1, 0, 1],
...                    [0, 1, 0]])
>>> y_pred = np.array([[1, 0, 0],
...                    [0, 1, 1]])
>>> multilabel_confusion_matrix(y_true, y_pred)
array([[[1, 0],
        [0, 1]],

       [[1, 0],
        [0, 1]],

       [[0, 1],
        [1, 0]]])

Или можно построить матрицу неточностей для каждой метки образца:

>>> multilabel_confusion_matrix(y_true, y_pred, samplewise=True)
array([[[1, 0],
        [1, 1]],

       [[1, 1],
        [0, 1]]])

Вот пример, демонстрирующий использование multilabel_confusion_matrix функции с многоклассовым вводом:

>>> y_true = ["cat", "ant", "cat", "cat", "ant", "bird"]
>>> y_pred = ["ant", "ant", "cat", "cat", "ant", "cat"]
>>> multilabel_confusion_matrix(y_true, y_pred,
...                             labels=["ant", "bird", "cat"])
array([[[3, 1],
        [0, 2]],

       [[5, 0],
        [1, 0]],

       [[2, 1],
        [1, 2]]])

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

Расчет отзыва (также называемого истинно положительным коэффициентом или чувствительностью) для каждого класса:

>>> y_true = np.array([[0, 0, 1],
...                    [0, 1, 0],
...                    [1, 1, 0]])
>>> y_pred = np.array([[0, 1, 0],
...                    [0, 0, 1],
...                    [1, 1, 0]])
>>> mcm = multilabel_confusion_matrix(y_true, y_pred)
>>> tn = mcm[:, 0, 0]
>>> tp = mcm[:, 1, 1]
>>> fn = mcm[:, 1, 0]
>>> fp = mcm[:, 0, 1]
>>> tp / (tp + fn)
array([1. , 0.5, 0. ])

Расчет специфичности (также называемой истинно отрицательной ставкой) для каждого класса:

>>> tn / (tn + fp)
array([1. , 0. , 0.5])

Расчет количества выпадений (также называемый частотой ложных срабатываний) для каждого класса:

>>> fp / (fp + tn)
array([0. , 1. , 0.5])

Расчет процента промахов (также называемого ложноотрицательным показателем) для каждого класса:

>>> fn / (fn + tp)
array([0. , 0.5, 1. ])

3.3.2.15. Рабочая характеристика приемника (ROC)

Функция roc_curve вычисляет рабочую характеристическую кривую приемника или кривую ROC . Цитата из Википедии:

«Рабочая характеристика приемника (ROC), или просто кривая ROC, представляет собой графический график, который иллюстрирует работу системы двоичного классификатора при изменении ее порога дискриминации. Он создается путем построения графика доли истинных положительных результатов из положительных (TPR = частота истинных положительных результатов) по сравнению с долей ложных положительных результатов из отрицательных (FPR = частота ложных положительных результатов) при различных настройках пороговых значений. TPR также известен как чувствительность, а FPR — это единица минус специфичность или истинно отрицательный показатель ».

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

>>> import numpy as np
>>> from sklearn.metrics import roc_curve
>>> y = np.array([1, 1, 2, 2])
>>> scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> fpr, tpr, thresholds = roc_curve(y, scores, pos_label=2)
>>> fpr
array([0. , 0. , 0.5, 0.5, 1. ])
>>> tpr
array([0. , 0.5, 0.5, 1. , 1. ])
>>> thresholds
array([1.8 , 0.8 , 0.4 , 0.35, 0.1 ])

На этом рисунке показан пример такой кривой ROC:

Функция roc_auc_score вычисляет площадь под операционной приемника характеристика (ROC) кривой, которая также обозначается через ППК или AUROC. При вычислении площади под кривой roc информация о кривой суммируется в одном номере. Для получения дополнительной информации см. Статью в Википедии о AUC.

По сравнению с такими показателями, как точность подмножества, потеря Хэмминга или оценка F1, ROC не требует оптимизации порога для каждой метки.

3.3.2.15.1. Двоичный регистр

В двоичном случае вы можете либо предоставить оценки вероятности, используя classifier.predict_proba() метод, либо значения решения без пороговых значений, заданные classifier.decision_function() методом. В случае предоставления оценок вероятности следует указать вероятность класса с «большей меткой». «Большая метка» соответствует classifier.classes_[1] и, следовательно classifier.predict_proba(X) [:, 1]. Следовательно, параметр y_score имеет размер (n_samples,).

>>> from sklearn.datasets import load_breast_cancer
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.metrics import roc_auc_score
>>> X, y = load_breast_cancer(return_X_y=True)
>>> clf = LogisticRegression(solver="liblinear").fit(X, y)
>>> clf.classes_
array([0, 1])

Мы можем использовать оценки вероятностей, соответствующие clf.classes_[1].

>>> y_score = clf.predict_proba(X)[:, 1]
>>> roc_auc_score(y, y_score)
0.99...

В противном случае мы можем использовать значения решения без порога.

>>> roc_auc_score(y, clf.decision_function(X))
0.99...

3.3.2.15.2. Мультиклассовый кейс

Функция roc_auc_score также может быть использована в нескольких классах классификации . В настоящее время поддерживаются две стратегии усреднения: алгоритм «один против одного» вычисляет среднее попарных оценок AUC ROC, а алгоритм «один против остальных» вычисляет среднее значение оценок ROC AUC для каждого класса по сравнению со всеми другими классами. В обоих случаях предсказанные метки предоставляются в виде массива со значениями от 0 до n_classes, а оценки соответствуют оценкам вероятности того, что выборка принадлежит определенному классу. Алгоритмы OvO и OvR поддерживают равномерное взвешивание ( average='macro') и по распространенности ( average='weighted').

Алгоритм «один против одного» : вычисляет средний AUC всех возможных попарных комбинаций классов. [HT2001] определяет метрику AUC мультикласса, взвешенную равномерно:
$$frac{1}{c(c-1)}sum_{j=1}^{c}sum_{k > j}^c (text{AUC}(j | k) + text{AUC}(k | j))$$

где $c$ количество классов и $text{AUC}(j | k)$ AUC с классом $j$ как положительный класс и класс $k$ как отрицательный класс. В общем, $text{AUC}(j | k) neq text{AUC}(k | j))$ в случае мультикласса. Этот алгоритм используется, установив аргумент ключевого слова , multiclass чтобы 'ovo' и average в 'macro'.

[HT2001] мультиклассируют AUC метрика может быть расширена , чтобы быть взвешены по распространенности:
$$frac{1}{c(c-1)}sum_{j=1}^{c}sum_{k > j}^c p(j cup k)( text{AUC}(j | k) + text{AUC}(k | j))$$

где cколичество классов. Этот алгоритм используется, установив аргумент ключевого слова , multiclass чтобы 'ovo' и average в 'weighted'. В 'weighted' опции возвращает распространенность усредненные , как описано в [FC2009] .

Алгоритм «один против остальных» : вычисляет AUC каждого класса относительно остальных [PD2000] . Алгоритм функционально такой же, как и в случае с несколькими этикетками. Чтобы включить этот алгоритм, установите для аргумента ключевого слова multiclass значение 'ovr'. Как и OvO, OvR поддерживает два типа усреднения: 'macro' [F2006] и 'weighted' [F2001] .

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

3.3.2.15.3. Кейс с несколькими метками

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

>>> from sklearn.datasets import make_multilabel_classification
>>> from sklearn.multioutput import MultiOutputClassifier
>>> X, y = make_multilabel_classification(random_state=0)
>>> inner_clf = LogisticRegression(solver="liblinear", random_state=0)
>>> clf = MultiOutputClassifier(inner_clf).fit(X, y)
>>> y_score = np.transpose([y_pred[:, 1] for y_pred in clf.predict_proba(X)])
>>> roc_auc_score(y, y_score, average=None)
array([0.82..., 0.86..., 0.94..., 0.85... , 0.94...])

И значения решений не требуют такой обработки.

>>> from sklearn.linear_model import RidgeClassifierCV
>>> clf = RidgeClassifierCV().fit(X, y)
>>> y_score = clf.decision_function(X)
>>> roc_auc_score(y, y_score, average=None)
array([0.81..., 0.84... , 0.93..., 0.87..., 0.94...])

Примеры:

См. В разделе « Рабочие характеристики приемника» (ROC) пример использования ROC для оценки качества выходных данных классификатора.
См. В разделе « Рабочие характеристики приемника» (ROC) с перекрестной проверкой пример использования ROC для оценки качества выходных данных классификатора с помощью перекрестной проверки.
См. В разделе Моделирование распределения видов пример использования ROC для моделирования распределения видов.

HT2001 ( 1 , 2 ) Рука, DJ и Тилль, RJ, (2001). Простое обобщение области под кривой ROC для задач классификации нескольких классов. Машинное обучение, 45 (2), стр. 171-186.
FC2009 Ферри, Сезар и Эрнандес-Оралло, Хосе и Модройу, Р. (2009). Экспериментальное сравнение показателей эффективности для классификации. Письма о распознавании образов. 30. 27-38.
PD2000 Провост Ф., Домингос П. (2000). Хорошо обученные ПЭТ: Улучшение деревьев оценки вероятностей (Раздел 6.2), Рабочий документ CeDER № IS-00-04, Школа бизнеса Стерна, Нью-Йоркский университет.
F2006 Фосетт, Т., 2006. Введение в анализ ROC. Письма о распознавании образов, 27 (8), стр. 861-874.
F2001Фосетт, Т., 2001. Использование наборов правил для максимизации производительности ROC в интеллектуальном анализе данных, 2001. Труды Международной конференции IEEE, стр. 131-138.

3.3.2.16. Компромисс при обнаружении ошибок (DET)

Функция det_curve вычисляет кривую компенсации ошибок обнаружения (DET) [WikipediaDET2017] . Цитата из Википедии:

«График компромисса ошибок обнаружения (DET) — это графическая диаграмма частоты ошибок для систем двоичной классификации, отображающая частоту ложных отклонений по сравнению с частотой ложных приемов. Оси x и y масштабируются нелинейно по их стандартным нормальным отклонениям (или просто с помощью логарифмического преобразования), в результате получаются более линейные кривые компромисса, чем кривые ROC, и большая часть области изображения используется для выделения важных различий в критический рабочий регион ».

Кривые DET представляют собой вариацию кривых рабочих характеристик приемника (ROC), где ложная отрицательная скорость нанесена на ось y вместо истинной положительной скорости. Кривые DET обычно строятся в масштабе нормального отклонения путем преобразования $phi^{-1}$ (с участием $phi$ — кумулятивная функция распределения). Полученные кривые производительности явно визуализируют компромисс типов ошибок для заданных алгоритмов классификации. См. [Martin1997], где приведены примеры и мотивация.

На этом рисунке сравниваются кривые ROC и DET двух примеров классификаторов для одной и той же задачи классификации:

Характеристики:

Кривые DET образуют линейную кривую по шкале нормального отклонения, если оценки обнаружения нормально (или близки к нормальному) распределены. В [Navratil2007] было показано, что обратное не обязательно верно, и даже более общие распределения могут давать линейные кривые DET.
При обычном преобразовании масштаба с отклонением точки распределяются таким образом, что занимает сравнительно большее пространство графика. Следовательно, кривые с аналогичными характеристиками классификации легче различить на графике DET.
С ложноотрицательной скоростью, «обратной» истинной положительной скорости, точкой совершенства для кривых DET является начало координат (в отличие от верхнего левого угла для кривых ROC).

Приложения и ограничения:

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

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

Примеры:

См. Кривую компенсации ошибок обнаружения (DET) для примера сравнения кривых рабочих характеристик приемника (ROC) и кривых компенсации ошибок обнаружения (DET).

Рекомендации:

ВикипедияDET2017 Авторы Википедии. Компромисс ошибки обнаружения. Википедия, свободная энциклопедия. 4 сентября 2017 г., 23:33 UTC. Доступно по адресу: https://en.wikipedia.org/w/index.php?title=Detection_error_tradeoff&oldid=798982054 . По состоянию на 19 февраля 2018 г.
Мартин 1997 А. Мартин, Дж. Доддингтон, Т. Камм, М. Ордовски и М. Пшибоцки, Кривая DET в оценке эффективности задач обнаружения , NIST 1997.
Навратил2007 Дж. Наврактил и Д. Клусачек, « О линейных DET », 2007 г. Международная конференция IEEE по акустике, обработке речи и сигналов — ICASSP ’07, Гонолулу, Гавайи, 2007 г., стр. IV-229-IV-232.

3.3.2.17. Нулевой проигрыш

Функция zero_one_loss вычисляет сумму или среднее значение потери 0-1 классификации ($L_{0−1}$) над $n_{samples}$. По умолчанию функция нормализуется по выборке. Чтобы получить сумму $L_{0−1}$, установите normalize значение False.

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

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ — соответствующее истинное значение, тогда потеря 0-1 $L_{0−1}$ определяется как:
$$L_{0-1}(y_i, hat{y}_i) = 1(hat{y}_i not= y_i)$$

где $1(x)$- индикаторная функция.

>>> from sklearn.metrics import zero_one_loss
>>> y_pred = [1, 2, 3, 4]
>>> y_true = [2, 2, 3, 4]
>>> zero_one_loss(y_true, y_pred)
0.25
>>> zero_one_loss(y_true, y_pred, normalize=False)
1

В случае с несколькими метками с двоичными индикаторами меток, где первый набор меток [0,1] содержит ошибку:

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
0.5

>>> zero_one_loss(np.array([[0, 1], [1, 1]]), np.ones((2, 2)),  normalize=False)
1

Пример:

См. В разделе « Рекурсивное исключение функции с перекрестной проверкой» пример использования нулевой потери для выполнения рекурсивного исключения функции с перекрестной проверкой.

3.3.2.18. Потеря очков по Брайеру

Функция brier_score_loss вычисляет оценку Шиповник для бинарных классов [Brier1950] . Цитата из Википедии:

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

Эта функция возвращает среднеквадратичную ошибку фактического результата. y∈{0,1} и прогнозируемая оценка вероятности $p=Pr⁡(y=1)$ ( pred_proba ) как выведено :
$$BS = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}} — 1}(y_i — p_i)^2$$

Потеря по шкале Бриера также составляет от 0 до 1, и чем ниже значение (средняя квадратичная разница меньше), тем точнее прогноз.

Вот небольшой пример использования этой функции:

>>> import numpy as np
>>> from sklearn.metrics import brier_score_loss
>>> y_true = np.array([0, 1, 1, 0])
>>> y_true_categorical = np.array(["spam", "ham", "ham", "spam"])
>>> y_prob = np.array([0.1, 0.9, 0.8, 0.4])
>>> y_pred = np.array([0, 1, 1, 0])
>>> brier_score_loss(y_true, y_prob)
0.055
>>> brier_score_loss(y_true, 1 - y_prob, pos_label=0)
0.055
>>> brier_score_loss(y_true_categorical, y_prob, pos_label="ham")
0.055
>>> brier_score_loss(y_true, y_prob > 0.5)
0.0

Балл Бриера можно использовать для оценки того, насколько хорошо откалиброван классификатор. Однако меньшая потеря по шкале Бриера не всегда означает лучшую калибровку. Это связано с тем, что по аналогии с разложением среднеквадратичной ошибки на дисперсию смещения потеря оценки по Бриеру может быть разложена как сумма потерь калибровки и потерь при уточнении [Bella2012]. Потеря калибровки определяется как среднеквадратическое отклонение от эмпирических вероятностей, полученных из наклона ROC-сегментов. Потери при переработке можно определить как ожидаемые оптимальные потери, измеренные по площади под кривой оптимальных затрат. Потери при уточнении могут изменяться независимо от потерь при калибровке, таким образом, более низкие потери по шкале Бриера не обязательно означают более качественную калибровку модели. «Только когда потеря точности остается неизменной, более низкая потеря по шкале Бриера всегда означает лучшую калибровку» [Bella2012] , [Flach2008] .

Пример:

См. Раздел « Калибровка вероятности классификаторов», где приведен пример использования потерь по шкале Бриера для выполнения калибровки вероятности классификаторов.

Рекомендации:

Brier1950 Дж. Брайер, Проверка прогнозов, выраженных в терминах вероятности , Ежемесячный обзор погоды 78.1 (1950)
Bella2012 ( 1 , 2 ) Белла, Ферри, Эрнандес-Оралло и Рамирес-Кинтана «Калибровка моделей машинного обучения» в Хосров-Пур, М. «Машинное обучение: концепции, методологии, инструменты и приложения». Херши, Пенсильвания: Справочник по информационным наукам (2012).
Flach2008 Флак, Питер и Эдсон Мацубара. «О классификации, ранжировании и оценке вероятности». Дагштульский семинар. Schloss Dagstuhl-Leibniz-Zentrum от Informatik (2008).

3.3.3. Метрики ранжирования с несколькими ярлыками

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

3.3.3.1. Ошибка покрытия

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

Примечание

Оценка нашей реализации на 1 больше, чем оценка, приведенная в Tsoumakas et al., 2010. Это расширяет ее для обработки вырожденного случая, когда экземпляр имеет 0 истинных меток.

Формально, учитывая двоичную индикаторную матрицу наземных меток истинности $y in left{0, 1right}^{n_text{samples} times n_text{labels}}$ и оценка, связанная с каждой меткой $hat{f} in mathbb{R}^{n_text{samples} times n_text{labels}}$ покрытие определяется как
$$coverage(y, hat{f}) = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}} — 1} max_{j:y_{ij} = 1} text{rank}_{ij}$$

с участием $text{rank}{ij} = left|left{k: hat{f}{ik} geq hat{f}_{ij} right}right|$. Учитывая определение ранга, связи y_scores разрываются путем присвоения максимального ранга, который был бы присвоен всем связанным значениям.

Вот небольшой пример использования этой функции:

>>> import numpy as np
>>> from sklearn.metrics import coverage_error
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> coverage_error(y_true, y_score)
2.5

3.3.3.2. Средняя точность ранжирования метки

В label_ranking_average_precision_score функции реализует маркировать ранжирование средней точности (LRAP). Этот показатель связан с average_precision_score функцией, но основан на понятии ранжирования меток, а не на точности и отзыве.

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

Формально, учитывая двоичную индикаторную матрицу наземных меток истинности $y in left{0, 1right}^{n_text{samples} times n_text{labels}}$ и оценка, связанная с каждой меткой $hat{f} in mathbb{R}^{n_text{samples} times n_text{labels}}$, средняя точность определяется как
$$LRAP(y, hat{f}) = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}} — 1} frac{1}{||y_i||0} sum{j:y_{ij} = 1} frac{|mathcal{L}{ij}|}{text{rank}{ij}}$$

где $mathcal{L}{ij} = left{k: y{ik} = 1, hat{f}{ik} geq hat{f}{ij} right}$, $text{rank}{ij} = left|left{k: hat{f}{ik} geq hat{f}_{ij} right}right|$, |cdot| вычисляет мощность набора (т. е. количество элементов в наборе), и $||cdot||_0$ это $ell_0$ «Norm» (который вычисляет количество ненулевых элементов в векторе).

Вот небольшой пример использования этой функции:

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_average_precision_score
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_average_precision_score(y_true, y_score)
0.416...

3.3.3.3. Потеря рейтинга

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

Формально, учитывая двоичную индикаторную матрицу наземных меток истинности $y in left{0, 1right}^{n_text{samples} times n_text{labels}}$ и оценка, связанная с каждой меткой $hat{f} in mathbb{R}^{n_text{samples} times n_text{labels}}$ потеря ранжирования определяется как
$$ranking_loss(y, hat{f}) = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}} — 1} frac{1}{||y_i||0(ntext{labels} — ||y_i||0)} left|left{(k, l): hat{f}{ik} leq hat{f}{il}, y{ik} = 1, y_{il} = 0 right}right|$$

где $|cdot|$ вычисляет мощность набора (т. е. количество элементов в наборе) и $||cdot||_0$ это $ell_0$ «Norm» (который вычисляет количество ненулевых элементов в векторе).

Вот небольшой пример использования этой функции:

>>> import numpy as np
>>> from sklearn.metrics import label_ranking_loss
>>> y_true = np.array([[1, 0, 0], [0, 0, 1]])
>>> y_score = np.array([[0.75, 0.5, 1], [1, 0.2, 0.1]])
>>> label_ranking_loss(y_true, y_score)
0.75...
>>> # With the following prediction, we have perfect and minimal loss
>>> y_score = np.array([[1.0, 0.1, 0.2], [0.1, 0.2, 0.9]])
>>> label_ranking_loss(y_true, y_score)
0.0

Рекомендации:

Цумакас, Г., Катакис, И., и Влахавас, И. (2010). Майнинг данных с несколькими метками. В справочнике по интеллектуальному анализу данных и открытию знаний (стр. 667-685). Springer США.

3.3.3.4. Нормализованная дисконтированная совокупная прибыль

Дисконтированный совокупный выигрыш (DCG) и Нормализованный дисконтированный совокупный выигрыш (NDCG) — это показатели ранжирования, реализованные в dcg_score и ndcg_score; они сравнивают предсказанный порядок с оценками достоверности, такими как релевантность ответов на запрос.

Со страницы Википедии о дисконтированной совокупной прибыли:

«Дисконтированная совокупная прибыль (DCG) — это показатель качества ранжирования. При поиске информации он часто используется для измерения эффективности алгоритмов поисковой системы или связанных приложений. Используя шкалу градуированной релевантности документов в наборе результатов поисковой системы, DCG измеряет полезность или выгоду документа на основе его позиции в списке результатов. Прирост накапливается сверху вниз в списке результатов, причем прирост каждого результата дисконтируется на более низких уровнях »

DCG упорядочивает истинные цели (например, релевантность ответов на запросы) в предсказанном порядке, затем умножает их на логарифмическое убывание и суммирует результат. Сумма может быть усечена после первогоKрезультатов, и в этом случае мы называем это DCG @ K. NDCG или NDCG @ $K$ — это DCG, деленная на DCG, полученную с помощью точного прогноза, так что оно всегда находится между 0 и 1. Обычно NDCG предпочтительнее DCG.

По сравнению с потерей ранжирования, NDCG может принимать во внимание оценки релевантности, а не ранжирование на основе фактов. Таким образом, если основополагающая информация состоит только из упорядочивания, предпочтение следует отдавать потере ранжирования; если основополагающая информация состоит из фактических оценок полезности (например, 0 для нерелевантного, 1 для релевантного, 2 для очень актуального), можно использовать NDCG.

Для одного образца, учитывая вектор непрерывных значений истинности для каждой цели $y in R^M$, где $M$ это количество выходов, а прогноз $hat{y}$, что индуцирует функцию ранжирования $f$, оценка DCG составляет
$$sum_{r=1}^{min(K, M)}frac{y_{f(r)}}{log(1 + r)}$$

а оценка NDCG — это оценка DCG, деленная на оценку DCG, полученную для $y$.

Рекомендации:

Запись в Википедии о дисконтированной совокупной прибыли
Джарвелин, К., и Кекалайнен, Дж. (2002). Оценка IR методов на основе накопленного коэффициента усиления. Транзакции ACM в информационных системах (TOIS), 20 (4), 422-446.
Ван, Ю., Ван, Л., Ли, Ю., Хе, Д., Чен, В., и Лю, Т. Ю. (2013, май). Теоретический анализ показателей рейтинга NDCG. В материалах 26-й ежегодной конференции по теории обучения (COLT 2013)
МакШерри Ф. и Наджорк М. (2008, март). Эффективность вычислений при поиске информации измеряется эффективно при наличии связанных оценок. В Европейской конференции по поиску информации (стр. 414-421). Шпрингер, Берлин, Гейдельберг.

3.3.4. Метрики регрессии

В sklearn.metrics модуле реализованы несколько функций потерь, оценки и полезности для измерения эффективности регрессии. Некоторые из них были расширены , чтобы обработать случай multioutput: mean_squared_error, mean_absolute_error, explained_variance_score и r2_score.

У этих функций есть multioutput аргумент ключевого слова, который определяет способ усреднения результатов или проигрышей для каждой отдельной цели. По умолчанию используется значение 'uniform_average', которое определяет равномерно взвешенное среднее значение по выходным данным. Если передается ndarrayформа shape (n_outputs,), то ее записи интерпретируются как веса, и возвращается соответствующее средневзвешенное значение. Если multioutputесть 'raw_values'указан, то все неизменные индивидуальные баллы или потери будут возвращены в массиве формы (n_outputs,).

r2_score и explained_variance_score принять дополнительное значение 'variance_weighted' для multioutput параметра. Эта опция приводит к взвешиванию каждой индивидуальной оценки по дисперсии соответствующей целевой переменной. Этот параметр определяет количественно зафиксированную немасштабированную дисперсию на глобальном уровне. Если целевые переменные имеют разную шкалу, то этот балл придает большее значение хорошему объяснению переменных с более высокой дисперсией. multioutput='variance_weighted' — значение по умолчанию r2_score для обратной совместимости. В будущем это будет изменено на uniform_average.

3.3.4.1. Оценка объясненной дисперсии

explained_variance_score вычисляет объясненной дисперсии регрессии балл.

Если $hat{y}$ — расчетный целевой объем производства, y соответствующий (правильный) целевой результат, и $Var$- Дисперсия , квадрат стандартного отклонения, то объясненная дисперсия оценивается следующим образом:
$$explained_{}variance(y, hat{y}) = 1 — frac{Var{ y — hat{y}}}{Var{y}}$$

Наилучшая возможная оценка — 1.0, более низкие значения — хуже.

Вот небольшой пример использования explained_variance_score функции:

>>> from sklearn.metrics import explained_variance_score
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> explained_variance_score(y_true, y_pred)
0.957...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> explained_variance_score(y_true, y_pred, multioutput='raw_values')
array([0.967..., 1.        ])
>>> explained_variance_score(y_true, y_pred, multioutput=[0.3, 0.7])
0.990...

3.3.4.2. Максимальная ошибка

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

Если $hat{y}_i$ прогнозируемое значение $i$-й образец, и $y_i$ — соответствующее истинное значение, тогда максимальная ошибка определяется как
$$text{Max Error}(y, hat{y}) = max(| y_i — hat{y}_i |)$$

Вот небольшой пример использования функции max_error:

>>> from sklearn.metrics import max_error
>>> y_true = [3, 2, 7, 1]
>>> y_pred = [9, 2, 7, 1]
>>> max_error(y_true, y_pred)
6

max_error не поддерживает multioutput.

3.3.4.3. Средняя абсолютная ошибка

Функция mean_absolute_error вычисляет среднюю абсолютную погрешность , риск метрики , соответствующей ожидаемого значение абсолютной потери или ошибок $l1$-нормальная потеря.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец, и $y_i$ — соответствующее истинное значение, тогда средняя абсолютная ошибка (MAE), оцененная за $n_{samples}$ определяется как
$$text{MAE}(y, hat{y}) = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}}-1} left| y_i — hat{y}_i right|.$$

Вот небольшой пример использования функции mean_absolute_error:

>>> from sklearn.metrics import mean_absolute_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_absolute_error(y_true, y_pred)
0.5
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_absolute_error(y_true, y_pred)
0.75
>>> mean_absolute_error(y_true, y_pred, multioutput='raw_values')
array([0.5, 1. ])
>>> mean_absolute_error(y_true, y_pred, multioutput=[0.3, 0.7])
0.85...

3.3.4.4. Среднеквадратичная ошибка

Функция mean_squared_error вычисляет среднюю квадратическую ошибку , риск метрики , соответствующую ожидаемое значение квадрата (квадратичной) ошибки или потерю.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец, и $y_i$ — соответствующее истинное значение, тогда среднеквадратичная ошибка (MSE), оцененная на $n_{samples}$ определяется как
$$text{MSE}(y, hat{y}) = frac{1}{n_text{samples}} sum_{i=0}^{n_text{samples} — 1} (y_i — hat{y}_i)^2.$$

Вот небольшой пример использования функции mean_squared_error:

>>> from sklearn.metrics import mean_squared_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> mean_squared_error(y_true, y_pred)
0.375
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> mean_squared_error(y_true, y_pred)
0.7083...

Примеры:

См. В разделе Регрессия повышения градиента пример использования среднеквадратичной ошибки для оценки регрессии повышения градиента.

3.3.4.5. Среднеквадратичная логарифмическая ошибка

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

Если $hat{y}_i$ прогнозируемое значение $i$-й образец, и $y_i$ — соответствующее истинное значение, тогда среднеквадратичная логарифмическая ошибка (MSLE), оцененная на $n_{samples}$ определяется как
$$text{MSLE}(y, hat{y}) = frac{1}{n_text{samples}} sum_{i=0}^{n_text{samples} — 1} (log_e (1 + y_i) — log_e (1 + hat{y}_i) )^2.$$

Где $log_e (x)$ означает натуральный логарифм $x$. Эту метрику лучше всего использовать, когда цели имеют экспоненциальный рост, например, численность населения, средние продажи товара в течение нескольких лет и т. Д. Обратите внимание, что эта метрика штрафует за заниженную оценку больше, чем за завышенную оценку.

Вот небольшой пример использования функции mean_squared_log_error:

>>> from sklearn.metrics import mean_squared_log_error
>>> y_true = [3, 5, 2.5, 7]
>>> y_pred = [2.5, 5, 4, 8]
>>> mean_squared_log_error(y_true, y_pred)
0.039...
>>> y_true = [[0.5, 1], [1, 2], [7, 6]]
>>> y_pred = [[0.5, 2], [1, 2.5], [8, 8]]
>>> mean_squared_log_error(y_true, y_pred)
0.044...

3.3.4.6. Средняя абсолютная ошибка в процентах

mean_absolute_percentage_error (MAPE), также известный как среднее абсолютное отклонение в процентах (МАПД), является метрикой для оценки проблем регрессии. Идея этой метрики — быть чувствительной к относительным ошибкам. Например, он не изменяется глобальным масштабированием целевой переменной.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ — соответствующее истинное значение, тогда средняя абсолютная процентная ошибка (MAPE), оцененная за $n_{samples}$ определяется как
$$text{MAPE}(y, hat{y}) = frac{1}{n_{text{samples}}} sum_{i=0}^{n_{text{samples}}-1} frac{{}left| y_i — hat{y}_i right|}{max(epsilon, left| y_i right|)}$$

где $epsilon$ — произвольное маленькое, но строго положительное число, чтобы избежать неопределенных результатов, когда y равно нулю.

В функции mean_absolute_percentage_error опоры multioutput.

Вот небольшой пример использования функции mean_absolute_percentage_error:

>>> from sklearn.metrics import mean_absolute_percentage_error
>>> y_true = [1, 10, 1e6]
>>> y_pred = [0.9, 15, 1.2e6]
>>> mean_absolute_percentage_error(y_true, y_pred)
0.2666...

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

3.3.4.7. Средняя абсолютная ошибка

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

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ — соответствующее истинное значение, тогда средняя абсолютная ошибка (MedAE), оцененная на $n_{samples}$ определяется как
$$text{MedAE}(y, hat{y}) = text{median}(mid y_1 — hat{y}_1 mid, ldots, mid y_n — hat{y}_n mid).$$

median_absolute_error Не поддерживает multioutput.

Вот небольшой пример использования функции median_absolute_error:

>>> from sklearn.metrics import median_absolute_error
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> median_absolute_error(y_true, y_pred)
0.5

3.3.4.8. R² балл, коэффициент детерминации

Функция r2_score вычисляет коэффициент детерминации , как правило , обозначенный как R².

Он представляет собой долю дисперсии (y), которая была объяснена независимыми переменными в модели. Он обеспечивает показатель степени соответствия и, следовательно, меру того, насколько хорошо невидимые выборки могут быть предсказаны моделью через долю объясненной дисперсии.

Поскольку такая дисперсия зависит от набора данных, R² не может быть значимо сопоставимым для разных наборов данных. Наилучшая возможная оценка — 1,0, и она может быть отрицательной (потому что модель может быть произвольно хуже). Постоянная модель, которая всегда предсказывает ожидаемое значение y, игнорируя входные характеристики, получит оценку R² 0,0.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ соответствующее истинное значение для общего n образцов, расчетный R² определяется как:
$$R^2(y, hat{y}) = 1 — frac{sum_{i=1}^{n} (y_i — hat{y}i)^2}{sum{i=1}^{n} (y_i — bar{y})^2}$$

где $bar{y} = frac{1}{n} sum_{i=1}^{n} y_i$ и $sum_{i=1}^{n} (y_i — hat{y}i)^2 = sum{i=1}^{n} epsilon_i^2$.

Обратите внимание, что r2_score вычисляется нескорректированное R² без поправки на смещение выборочной дисперсии y.

Вот небольшой пример использования функции r2_score:

>>> from sklearn.metrics import r2_score
>>> y_true = [3, -0.5, 2, 7]
>>> y_pred = [2.5, 0.0, 2, 8]
>>> r2_score(y_true, y_pred)
0.948...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='variance_weighted')
0.938...
>>> y_true = [[0.5, 1], [-1, 1], [7, -6]]
>>> y_pred = [[0, 2], [-1, 2], [8, -5]]
>>> r2_score(y_true, y_pred, multioutput='uniform_average')
0.936...
>>> r2_score(y_true, y_pred, multioutput='raw_values')
array([0.965..., 0.908...])
>>> r2_score(y_true, y_pred, multioutput=[0.3, 0.7])
0.925...

Пример:

См. В разделе « Лассо и эластичная сеть для разреженных сигналов» приведен пример использования показателя R² для оценки лассо и эластичной сети для разреженных сигналов.

3.3.4.9. Средние отклонения Пуассона, Гаммы и Твиди

Функция mean_tweedie_deviance вычисляет среднюю ошибку Deviance Tweedie с powerпараметром ($p$). Это показатель, который выявляет прогнозируемые ожидаемые значения целей регрессии.

Существуют следующие особые случаи:

когда power=0 это эквивалентно mean_squared_error.
когда power=1 это эквивалентно mean_poisson_deviance.
когда power=2 это эквивалентно mean_gamma_deviance.

Если $hat{y}_i$ прогнозируемое значение $i$-й образец и $y_i$ — соответствующее истинное значение, тогда средняя ошибка отклонения Твиди (D) для мощности $p$, оценивается более $n_{samples}$ определяется как

Отклонение от твиди — однородная функция степени 2-power. Таким образом, гамма-распределение power=2 означает, что одновременно масштабируется y_true и y_pred не влияет на отклонение. Для распределения Пуассона power=1 отклонение масштабируется линейно, а для нормального распределения ( power=0) — квадратично. В общем, чем выше, powerтем меньше веса придается крайним отклонениям между истинными и прогнозируемыми целевыми значениями.

Например, давайте сравним два прогноза 1.0 и 100, которые оба составляют 50% от их соответствующего истинного значения.

Среднеквадратичная ошибка ( power=0) очень чувствительна к разнице прогнозов второй точки:

>>> from sklearn.metrics import mean_tweedie_deviance
>>> mean_tweedie_deviance([1.0], [1.5], power=0)
0.25
>>> mean_tweedie_deviance([100.], [150.], power=0)
2500.0

Если увеличить powerдо 1:

>>> mean_tweedie_deviance([1.0], [1.5], power=1)
0.18...
>>> mean_tweedie_deviance([100.], [150.], power=1)
18.9...

разница в ошибках уменьшается. Наконец, установив power=2:

>>> mean_tweedie_deviance([1.0], [1.5], power=2)
0.14...
>>> mean_tweedie_deviance([100.], [150.], power=2)
0.14...

мы получим идентичные ошибки. Таким образом, отклонение when power=2чувствительно только к относительным ошибкам.

3.3.5. Метрики кластеризации

В модуле sklearn.metrics реализованы несколько функций потерь, оценки и полезности. Для получения дополнительной информации см. Раздел « Оценка производительности кластеризации » для кластеризации экземпляров и « Оценка бикластеризации» для бикластеризации.

3.3.6. Фиктивные оценки

При обучении с учителем простая проверка работоспособности состоит из сравнения своей оценки с простыми практическими правилами. DummyClassifier реализует несколько таких простых стратегий классификации:

stratified генерирует случайные прогнозы, соблюдая распределение классов обучающего набора.
most_frequent всегда предсказывает наиболее частую метку в обучающем наборе.
prior всегда предсказывает класс, который максимизирует предыдущий класс (как most_frequent) и predict_proba возвращает предыдущий класс.
uniform генерирует предсказания равномерно в случайном порядке.
constant всегда предсказывает постоянную метку, предоставленную пользователем. Основная мотивация этого метода — оценка F1, когда положительный класс находится в меньшинстве.

Обратите внимание, что со всеми этими стратегиями predict метод полностью игнорирует входные данные!

Для иллюстрации DummyClassifier сначала создадим несбалансированный набор данных:

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> y[y != 1] = -1
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

Далее сравним точность SVC и most_frequent:

>>> from sklearn.dummy import DummyClassifier
>>> from sklearn.svm import SVC
>>> clf = SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.63...
>>> clf = DummyClassifier(strategy='most_frequent', random_state=0)
>>> clf.fit(X_train, y_train)
DummyClassifier(random_state=0, strategy='most_frequent')
>>> clf.score(X_test, y_test)
0.57...

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

>>> clf = SVC(kernel='rbf', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.94...

Мы видим, что точность увеличена почти до 100%. Для лучшей оценки точности рекомендуется стратегия перекрестной проверки, если она не требует слишком больших затрат на ЦП. Для получения дополнительной информации см. Раздел « Перекрестная проверка: оценка производительности оценщика ». Более того, если вы хотите оптимизировать пространство параметров, настоятельно рекомендуется использовать соответствующую методологию; подробности см. в разделе « Настройка гиперпараметров оценщика ».

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

DummyRegressor также реализует четыре простых правила регрессии:

mean всегда предсказывает среднее значение тренировочных целей.
median всегда предсказывает медианное значение тренировочных целей.
quantile всегда предсказывает предоставленный пользователем квантиль учебных целей.
constant всегда предсказывает постоянное значение, предоставляемое пользователем.

Во всех этих стратегиях predict метод полностью игнорирует входные данные.

Источник

Перевод

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

Показатели эффективности для точности и отзыва в мультиклассовой классификации (также известной как классификация по нескольким меткам) могут быть немного — или очень — запутанными, поэтому в этом посте я объясню, как используются точность и отзыв и как они рассчитываются. Это на самом деле довольно просто! Но сначала давайте начнем с краткого обзора точности и вспомним бинарную классификацию. (Есть также Часть II: счет F1, но я рекомендую начать с первой части).

В бинарной классификации у нас обычно есть два класса, часто называемые положительными и отрицательными, и мы пытаемся предсказать класс для каждой выборки. Давайте рассмотрим простой пример: наши данные представляют собой набор изображений, некоторые из которых содержат собаку. Мы заинтересованы в обнаружении фотографий с собаками. В этом случае наш Позитивный класс — это класс всех фотографий собак, а Негативный класс включает в себя все остальные фотографии. Другими словами, если образец фотографии содержит собаку, это позитив. Если это не так, это отрицательный. Наш классификатор предсказывает для каждой фотографии, является ли она положительной (P) или отрицательной (N): есть ли собака на фотографии?

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

Вот простой пример. Предположим, у нас есть 10 фотографий, и ровно 7 из них имеют собак. Если бы наш классификатор был идеален, матрица путаницы выглядела бы так:

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

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

В этом примере 2 фотографии с собаками были классифицированы как негативные (нет собаки!), А 1 фотография без собаки была классифицирована как позитивные (собака!).

Когда положительный образецложноклассифицируется как отрицательный, мы называем это ложным отрицательным (FN). И аналогично, когда отрицательный образецложноклассифицируется как положительный, он называется ложным положительным. Ниже мы копируем матрицу путаницы, но добавляем TP, FP, FN и TN для обозначения значений True Positive, False Position, False Negative и True Negative:

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

Давайте начнем сточность, который отвечает на следующий вопрос: какая доляпрогнозируемые позитивыдействительно положительно? Нам нужно посмотреть на общее количество прогнозируемых позитивов (истинные позитивы плюс ложные позитивы, TP + FP) и посмотреть, сколько из них являются истинно позитивными (TP). В нашем случае 5 + 1 = 6 фотографий были предсказаны как положительные, но только 5 из них являются настоящими положительными. Таким образом, точность в нашем случае составляет 5 / (5 + 1) =83,3%, В целом, точность равна TP / (TP + FP). Обратите внимание, что TP + FP является суммойПервая строка,

Еще одна очень полезная мераотзыв, который отвечает на другой вопрос: какая доляфактические Позитивыправильно классифицирован? Глядя на таблицу, мы видим, что количество фактических позитивов составляет 2 + 5 = 7 (TP + FN). Из этих 7 фотографий 5 были предсказаны как положительные. Напоминаем, таким образом, 5/7 =71,4%, В общем, вспомним ТП / (ТП + ФН). Обратите внимание, что TP + FN является суммойпервый столбец,

Можно также интересоватьсяточность: какая доля фотографий — как положительных, так и отрицательных — была правильно классифицирована? В нашем случае 5 + 2 = 7 фотографий были правильно классифицированы из общего числа 10. Таким образом, точность составляет 70,0%. Вообще говоря, из фотографий TP + TN + FP + FN есть в общей сложности фотографии TP + TN, и поэтому общая формула точности (TP + TN) / (TP + TN + FP + FN).

Что важнее, точность или отзыв? Это действительно зависит от вашей конкретной проблемы классификации. Представьте, например, что вашему классификатору необходимо выявлять диабет у людей. «Положительный» означает, что у пациента диабет. «Отрицательный» означает, что пациент здоров. (Я знаю, это сбивает с толку. Но это медицинский жаргон!) В этом случае вы, вероятно, захотите убедиться в том, что ваш классификатор имеет высокий уровень отклика, чтобы правильно выявлялось как можно больше диабетиков. Возьмем другой пример — скажем, вы создаете систему рекомендаций по видео, и ваш классификатор прогнозирует «Позитивный» для релевантного видео и «Негативный» для не релевантного видео. Вы хотите убедиться, что почти все рекомендуемые видео относятся к пользователю, поэтому вам нужна высокая точность. Жизнь полна компромиссов, и это также верно для классификаторов. Обычно есть компромисс между хорошей точностью и хорошим отзывом. Вы обычно не можете иметь оба.

Наш пример с собакой был проблемой двоичной классификации. Проблемы бинарной классификации часто сосредоточены на Позитивном классе, который мы хотим обнаружить. Напротив, в типичной многоклассовой проблеме классификации нам нужно классифицировать каждую выборку в 1 из N различных классов. Возвращаясь к нашему примеру с фотографиями, представьте, что у нас есть коллекция фотографий. На каждой фотографии изображено одно животное: либоКот,рыбыиликурицы, Наш классификатор должен предсказать, какое животное показано на каждой фотографии. Это проблема классификации с N = 3 классами.

Давайте посмотрим на образец матрицы путаницы, которая создается после классификации 25 фотографий:

Подобно нашему двоичному случаю, мы можем определить точность и вызвать для каждого из классов. Например,точностьдля класса Cat — количество правильно предсказанных фотографий Cat (4) из всех предсказанных фотографий Cat (4 + 3 + 6 = 13), что составляет 4/13 = 30,8%. Так что только около 1/3 фотографий, которые наш предсказатель классифицирует как кошку, на самом деле являются кошками!

С другой стороны,отзывдля Cat — количество правильно спрогнозированных фотографий Cat (4) из числа действительных фотографий Cat (4 + 1 + 1 = 6), что составляет 4/6 = 66,7%. Это означает, что наш классификатор классифицировал 2/3 фотографий кошек как Cat.

Аналогичным образом мы можем вычислить точность и вспомнить для двух других классов: Рыба и Курица. Для рыбы эти цифры составляют 66,7% и 20,0% соответственно. Для курицы число для точности и отзыва составляет 66,7%. Идите и проверьте эти результаты. Вы можете использовать два изображения ниже, чтобы помочь вам.

В библиотеке Scikit-Learn Python (также известный какsklearn), вы можете легко вычислить точность и вызвать для каждого класса в классификаторе мультикласса. Удобная функция для использования здесьsklearn.metrics.classification_report,

Вот некоторый код, который использует наш пример Cat / Fish / Hen. Сначала я создал список с истинными классами изображений (y_true) и предсказанными классами (y_pred). Обычно y_pred генерируется с использованием классификатора — здесь я устанавливаю его значения вручную, чтобы соответствовать матрице путаницы.

В строке 14 выводится запутанная матрица, а затем в строке 17 выводятся точность и отзыв для трех классов.

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

classification_reportтакже сообщает о других показателях (например, F1-оценка). В следующем посте я объяснюF1-оценкадля случая мультикласса, и почему вы не должны его использовать

Надеюсь, вы нашли этот пост полезным и легким для понимания!

Продолжите к части II: счет F1

Источник

Содержание

1 Общие понятия
2 Простые оценки
3 Различные виды агрегации Precision и Recall
4 F-мера
5 ROC-кривая
6 Precision-Recall кривая
7 Источники

Общие понятия

TP — true positive: классификатор верно отнёс объект к рассматриваемому классу.
TN — true negative: классификатор верно утверждает, что объект не принадлежит к рассматриваемому классу.
FP — false positive: классификатор неверно отнёс объект к рассматриваемому классу.
FN — false negative: классификатор неверно утверждает, что объект не принадлежит к рассматриваемому классу.

Здесь про TP, TN, FP, FN и понятия, через них выражающиеся, мы говорим в рамках одного класса бинарной классификации. То есть, в такой системе подразумевается, что реальное число объектов класса 0 (для бинарного случая 0/1) может выражаться как

Confusion matrix (матрица ошибок / несоответствий / потерь, CM)

Вычисление TP, FP, FN по CM

— квадратная матрица размера k × k, где — число объектов класса ,
которые были квалифицированны как класс , а — число классов. Значения ячеек CM могут быть вычислены по формуле:
, где — реальный класс объекта, а — предсказанный.

Для бинарного случая:

	Принадлежит классу (P)	Не принадлежит классу (N)
Предсказана принадлежность классу	TP	FP
Предсказано отсутствие принадлежности к классу	FN	TN

Для многоклассовой классификации матрица несоответствий строится по тому же принципу:

Предсказанный класс	Класс 1 (C₁)	Класс 2 (C₂)	Класс 3 (C₃)
1 (P₁)	T₁	F₁₂	F₁₃
2 (P₂)	F₂₁	T₂	F₂₃
3 (P₃)	F₃₁	F₃₂	T₃

В этом случае TP, TN, FP и FN считаются относительно некоторого класса следующим образом:

Простые оценки

Accuracy — (точность) показывает долю правильных классификаций. Несмотря на очевидность и простоту, является одной из самых малоинформативных оценок классификаторов.

Recall — (полнота, sensitivity, TPR (true positive rate)) показывает отношение верно классифицированных объектов класса к общему числу элементов этого класса.

Precision — (точность, перевод совпадает с accuracy)показывает долю верно классифицированных объектов среди всех объектов, которые к этому классу отнес классификатор.

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

Fall-out — (FPR (false positive rate)) показывает долю неверных срабатываний классификатора к общему числу объектов за пределами класса. Иначе говоря то, насколько часто классификатор ошибается при отнесении того или иного объекта к классу.

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

Precision

Recall

Различные виды агрегации Precision и Recall

Примеры и картинки взяты из лекций курса «Введение в машинное обучение»^[1] К.В. Воронцова

Арифметическое среднее:

Линии уровня для среднего арифметического

Если precision = 0.05, recall = 1, то A = 0.525
Если precision = 0.525, recall = 0.525, то A = 0.525.
Первый классификатор — константный, не имеет смысла.
Второй классификатор показывает неплохое качество.

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

Минимум:

Линии уровня для минимума

Если precision = 0.05, recall = 1, то M = 0.05
Если precision = 0.525, recall = 0.525, то M = 0.525.

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

Если precision = 0.2, recall = 1, то M = 0.2.
Если precision = 0.2, recall = 0.3, то M = 0.2.

Но не отличает классификаторы с разными неминимальными показателями.

Гармоническое среднее, или F-мера:

Если precision = 0.05, recall = 1, то F = 0.1.
Если precision = 0.525, recall = 0.525, то F = 0.525.
Если precision = 0.2, recall = 1, то F = 0.33.
Если precision = 0.2, recall = 0.3, то F = 0.24.

Является наиболее точным усреднением, учитывает оба показателя.

Геометрическое среднее, или Индекс Фоулкса–Мэллова (Fowlkes–Mallows index)

Менее строгая мера.

F-мера

Для общей оценки качества классификатора часто используют F₁-меру. Оригинально она вычисляется для позитивного класса случая бинарной классификации, обобщается с помощью приниципа «‎один против всех» (описан подробнее ниже, для многоклассовой классификации). F₁-мера — среднее гармоническое между precision и recall:

Среднее гармоническое взвешенное F_β (F₁-мера — частный случай F_β-меры для β = 1).
F_β измеряет эффективность классификатора учитывая recall в β раз более важным чем precision:

F-мера для многоклассовой классификации. Три вида усреднения

Принцип усреднения различных F-мер для нескольких классов

Вычисление TP, FP, FN для многоклассовой классификации

Для вычисления F-меры (и других) метрик в рамках многоклассовой классификации используется подход «один против всех»: каждый класс ровно один раз становится «положительным»,
а остальные — отрицательным (пример вычисления изображён на матрице).

Таким образом, в зависимости от этапа вычисления, на котором производится усреднение, можно вычислить micro-average, macro-average и average F-меры (логика вычисления изображена на схеме справа).
Микро- и макро-:

где для micro-average precision и recall вычислены из усреднённых TP, FP, FN;

для macro-average precision и recall вычислены из усреднённых precision_i, recall_i;

Усреднённая:

где — индекс класса, а — число классов.

ROC-кривая

ROC-кривая; оранжевым показан идеальный алгоритм, фиолетовым — типичный, а синим — худший

Для наглядной оценки качества алгоритма применяется ROC-кривая. Кривая строится на плоскости, определённой TPR (по оси ординат) и FPR (по оси абсцисс).

Для построении графика используется мягкая классификация: вместо того, чтобы чётко отнести объект к классу, классификатор возвращает вероятности принадлежности объекта к различным классам. Эта уверенность сравнивается с порогом (какой уверенности «достаточно», чтобы отнести объект к положительному классу). В зависимости от значения этого порога меняются значения TPR и FPR.

Алгоритм построения кривой:

Запустить классификатор на тестовой выборке
Отсортировать результаты по уверенности классификатора в принадлежности объекта к классу
Пока не кончились элементы:
1. Взять объект с максимальной уверенностью
2. Сравнить метку с реальной
3. Пересчитать TPR и FPR на взятых объектах
4. Поставить точку, если обе характеристики не NaN / ±∞
Построить кривую по точкам

Таким образом:
число точек не превосходит число объектов
идеальному алгоритму соответствует ROC-кривая, проходящая через точку
худшему алгоритму (например, монетке) соответствует прямая TPR = FPR.

Для численной оценки алгоритма по ROC-кривой используется значение площади под ней (AUC, area under curve). Идеальный алгоритм имеет AUC, равный 1, худший — 0,5.

С другой стороны, для построения ROC-кривой не обязательно пересчитывать TPR и FPR.

Существует альтернативный алгоритм построения ROC-кривой.

сортируем объекты по уверенности классификатора в их принадлежности к положительному классу
начинаем в точке (0, 0)
последовательно продолжаем кривую вверх:
- для каждого «отрицательного» объекта вверх
- для каждого «положительного» — вправо.

Корректность алгоритма обосновывается тем, что с изменением предсказания для одного объекта в зависимости от его класса меняется либо TPR, либо FPR (значение второго параметра остаётся прежним). Ниже описана другая логика, подводящая к алгоритму выше.

График Accuracy для идеальной классификации

ROC-кривая для идеальной классификации

График Accuracy для неидеальной классификации

ROC-кривая для неидеальной классификации

Напомним, что мы работаем с мягкой классификацией.

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

Начнём перебирать «границу раздела»: если граница в нуле — мы решаем относить все объекты к положительному классу, тогда accuracy = 1/2.
Последовательно сдвигаем границу по единичке вправо:

если реальный класс объекта, оказавшегося теперь по другую сторону границы — отрицательный, то accuracy увеличивается, так как мы «угадали» класс объекта, решив относить объекты левее границы к отрицательному классу;
если же реальный класс объекта — положительный, accuracy уменьшается (по той же логике)

Таким образом, на графиках слева, видно, что:

на графике идеальной классификации точность в 100% достигается, неидеальной — нет;
площадь под графиком accuracy идеального классификатора больше, чем аналогичная площадь для неидеального.

Заметим, что, повернув график на 45 градусов, мы получим ROC-кривые для соответствующих классификаторов (графикам accuracy слева соответствуют ROC-кривые справа). Так объясняется альтернативный алгоритм построения ROC-кривой.

Precision-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)

Источники

Coursera: https://www.coursera.org/learn/vvedenie-mashinnoe-obuchenie
Оценка качества в задачах классификации и регрессии
Лекции А. Забашта
Лекции Е. А. Соколова
Оценка классификатора (точность, полнота, F-мера)

↑ https://web.archive.org/web/20220226120201/https://www.coursera.org/learn/vvedenie-mashinnoe-obuchenie

Источник