Матрица ошибок как построить

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

Что такое Матрица путаницы в машинном обучении

  Перевод

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

Сделать путаницу менее запутанной.

Матрица путаницы — это метод для подведения итогов работы алгоритма классификации.

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

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

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

Прочитав этот пост, вы узнаете:

• Что такое матрица путаницы и зачем вам ее использовать?
• Как рассчитать путаницу для двухклассовой задачи классификации с нуля.
• Как создать путаницу в Weka, Python и R.

Давайте начнем.

• Обновление октябрь 2017Исправлена ​​небольшая ошибка в сработавшем примере (спасибо Raktim).
• Обновление дек / 2017: Исправлена ​​небольшая ошибка в расчете точности (спасибо Robson Pastor Alexandre)

Точность классификации и ее ограничения

Точность классификации — это отношение правильных прогнозов к общим сделанным прогнозам.

classification accuracy = correct predictions / total predictions

Это часто представляется в процентах путем умножения результата на 100.

classification accuracy = correct predictions / total predictions * 100

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

error rate = (1 - (correct predictions / total predictions)) * 100

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

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

1. При данных данных имеется более 2 классов. С 3 или более классами вы можете получить точность классификации 80%, но вы не знаете, так ли это, потому что все классы предсказываются одинаково хорошо, или модель игнорирует один или два класса.
2. Когда ваши данные не имеют четного количества классов. Вы можете достичь точности 90% или более, но это не очень хорошая оценка, если 90 записей на каждые 100 принадлежат одному классу, и вы можете достичь этой оценки, всегда прогнозируя наиболее распространенное значение класса.

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

Что такое Матрица замешательства?

Матрица путаницы — это краткое изложение результатов прогнозирования по проблеме классификации.

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

Матрица путаницы показывает, как ваша модель классификации
смущен, когда он делает прогнозы.

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

Именно эта разбивка преодолевает ограничение использования только точности классификации.

Как вычислить матрицу путаницы

Ниже приведен процесс расчета Матрицы путаницы.

1. Вам нужен набор данных теста или набор данных проверки с ожидаемыми значениями результата.
2. Сделайте прогноз для каждой строки в вашем тестовом наборе данных.
3. Из ожидаемых результатов и прогнозов рассчитывают:
   1. Количество правильных прогнозов для каждого класса.
   2. Количество неверных прогнозов для каждого класса, организованных классом, которое было предсказано.

Эти числа затем организуются в таблицу или матрицу следующим образом:

• Ожидается вниз: Каждая строка матрицы соответствует прогнозируемому классу.
• Предсказано через вершинуКаждый столбец матрицы соответствует фактическому классу.

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

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

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

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

— страница 145, Введение в статистическое обучение: с приложениями в R 2014

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

Давайте сделаем это объяснение создания беспорядочной матрицы конкретным на примере.

Матрица путаницы 2-х классов

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

У нас есть тестовый набор данных из 10 записей с ожидаемыми результатами и набор прогнозов из нашего алгоритма классификации.

Expected, 	Predicted
man,		woman
man, 		man
woman,		woman
man,		man
woman,		man
woman, 		woman
woman, 		woman
man, 		man
man, 		woman
woman, 		woman

Давайте начнем и вычислим точность классификации для этого набора прогнозов.

Алгоритм сделал 7 из 10 прогнозов правильными с точностью до 70%.

accuracy = total correct predictions / total predictions made * 100
accuracy = 7 / 10 * 100

Но какие ошибки были сделаны?

Давайте превратим наши результаты в путаницу.

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

men classified as men: 3
women classified as women: 4

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

men classified as women: 2
woman classified as men: 1

Теперь мы можем расположить эти значения в матрицу смешения 2-х классов:

men	women
men		3	1
women	2	4

Мы можем многому научиться из этой таблицы.

• Общее фактическое число мужчин в наборе данных является суммой значений в столбце мужчин (3 + 2)
• Общая фактическая численность женщин в наборе данных представляет собой сумму значений в столбце женщин (1 + 4).
• Правильные значения расположены по диагонали от левого верхнего до правого нижнего угла матрицы (3 + 4).
• Больше ошибок было сделано при прогнозировании мужчин как женщин, чем при прогнозировании женщин как мужчин.

Проблемы двух классов особенные

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

Например, болезненное состояние или событие без какого-либо болезненного состояния или какого-либо события

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

Это дает нам:

• «истинно положительный”Для правильно предсказанных значений событий.
• «ложно положительный”Для неправильно предсказанных значений событий.
• «правда отрицательный”Для правильно предсказанных значений без событий.
• «ложноотрицательный”Для неправильно предсказанных значений без событий.

Мы можем обобщить это в матрице путаницы следующим образом:

event			no-event
event		true positive		false positive
no-event	false negative		true negative

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

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

Рассмотрим случай, когда есть два класса. […] Верхняя строка таблицы соответствует образцам, прогнозируемым как события. Некоторые предсказаны правильно (истинные положительные результаты или TP), в то время как другие неточно классифицированы (ложные положительные результаты или FP). Аналогично, вторая строка содержит предсказанные отрицательные значения с истинными отрицательными значениями (TN) и ложными отрицательными значениями (FN).

— страница 256, Прикладное прогнозное моделирование, 2013

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

Примеры кода матрицы путаницы

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

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

Пример путаницы в Weka

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

Ниже приведен скриншот интерфейса Weka Explorer после обучения алгоритму k-ближайшего соседа в наборе данных диабета индейцев Пима.

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

Матрица путаницы назначает буквы a и b значениям класса и предоставляет ожидаемые значения класса в строках и прогнозируемые значения класса («классифицированные как») для каждого столбца.

Вы можете узнать больше о Weka Machine Learning Workbench здесь,

Пример путаницы в Python с scikit-learn

Библиотека scikit-learn для машинного обучения в Python может вычислить матрицу путаницы.

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

# Example of a confusion matrix in Python
from sklearn.metrics import confusion_matrix

expected = [1, 1, 0, 1, 0, 0, 1, 0, 0, 0]
predicted = [1, 0, 0, 1, 0, 0, 1, 1, 1, 0]
results = confusion_matrix(expected, predicted)
print(results)

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

[[4 2]
[1 3]]

Узнайте больше о функция confusion_matrix () в документации по scikit-learn API,

Пример путаницы в R с кареткой

Библиотека карет для машинного обучения в R может вычислить матрицу путаницы

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

# example of a confusion matrix in R
library(caret)

expected <- factor(c(1, 1, 0, 1, 0, 0, 1, 0, 0, 0))
predicted <- factor(c(1, 0, 0, 1, 0, 0, 1, 1, 1, 0))
results <- confusionMatrix(data=predicted, reference=expected)
print(results)

Выполнение этого примера вычисляет отчет матрицы путаницы и связанную статистику и печатает результаты.

Confusion Matrix and Statistics

          Reference
Prediction 0 1
         0 4 1
         1 2 3

               Accuracy : 0.7
                 95% CI : (0.3475, 0.9333)
    No Information Rate : 0.6
    P-Value [Acc > NIR] : 0.3823

                  Kappa : 0.4
 Mcnemar's Test P-Value : 1.0000

            Sensitivity : 0.6667
            Specificity : 0.7500
         Pos Pred Value : 0.8000
         Neg Pred Value : 0.6000
             Prevalence : 0.6000
         Detection Rate : 0.4000
   Detection Prevalence : 0.5000
      Balanced Accuracy : 0.7083

       'Positive' Class : 0

В этом отчете содержится много информации, не в последнюю очередь — сама матрица путаницы.

Узнайте больше о Функция confusionMatrix () в документации API каретки [PDF].

Дальнейшее чтение

О матрице путаницы написано не так много, но в этом разделе перечислены некоторые дополнительные ресурсы, которые могут вас заинтересовать.

• Матрица путаницы в Википедии
• Простое руководство по терминологии путаницы
• Путаница матрица онлайн калькулятор

Резюме

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

В частности, вы узнали о:

• Ограничения точности классификации и когда это может скрыть важные детали.
• Матрица путаницы и как рассчитать ее с нуля и интерпретировать результаты.
• Как вычислить матрицу путаницы с библиотеками Weka, Python scikit-learn и R caret.

У вас есть вопросы?
Задайте свой вопрос в комментариях ниже, и я сделаю все возможное, чтобы ответить на них.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ROC-кривая

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

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

,

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

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

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

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

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

Precison-recall кривая

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

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

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

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

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

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

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

и

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

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

См. также

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример 2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import sklearn.metrics

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

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

 

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

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

import numpy

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

 

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

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

import sklearn.metrics
import numpy

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

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

 

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

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

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

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

 

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

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

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

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

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

1. Accuracy
2. Precision
3. Recall

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

Метрика Accuracy

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

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

import numpy
import sklearn.metrics

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

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

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

 

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

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

 

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

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

Precision

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

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

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

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

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

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

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

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

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

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

import sklearn.metrics

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

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

 

Вывод: 0.6666666666666666.

Recall

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

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

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

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

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

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

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

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

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

import sklearn.metrics

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

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

 

Вывод: 0.6666666666666666.

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

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

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

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

Precision или Recall?

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

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

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

Вывод

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

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

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

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

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

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

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

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

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

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

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

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

True Positive (TP)

True Negative (TN)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

96%! Неплохо!

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

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

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

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

Precision vs. Recall

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

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

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

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

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

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

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

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

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

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

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

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

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

F1-Score

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

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

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

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

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

# confusion matrix in sklearn

from sklearn.metrics import confusion_matrix

3 from sklearn.metrics import classification_report

# actual values

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

# predicted values

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

# confusion matrix

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

print(‘Confusion matrix : n’,matrix)

# outcome values order in sklearn

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

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

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

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

print(‘Classification report : n’,matrix)

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

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

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

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

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

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

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

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

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

Заключение

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

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

В задачах классификации, если точность предсказания просто представлена ​​вероятностью успешного предсказания, иногда даже если достигается точность 99,9%, это не обязательно означает, что модель и алгоритм хороши, например, проблемы рака, если рак возникает. Коэффициент составляет всего 0,01%, поэтому, если алгоритм всегда дает предсказуемый результат, он также может достичь высокой степени точности.

Матрица путаницы

Возьмем, к примеру, рак, 0 означает отсутствие болезни, 1 означает заболевание, а численность населения составляет 10 000 человек:

Точность и скорость звонков

Код

# Подготовить данные
import numpy as np
from sklearn import datasets

digits = datasets.load_digits()
X = digits['data']
y = digits['target'].copy()

 # Вручную перекосить данные набора цифр 9
y[digits['target']==9] = 1
y[digits['target']!=9] = 0

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=666)

log_reg = LogisticRegression()
log_reg.fit(X_train,y_train)
log_reg.score(X_test,y_test)

y_log_predict = log_reg.predict(X_test)

def TN(y_true,y_predict):
    return np.sum((y_true==0)&(y_predict==0))
TN(y_test,y_log_predict)

def FP(y_true,y_predict):
    return np.sum((y_true==0)&(y_predict==1))
FP(y_test,y_log_predict)

def FN(y_true,y_predict):
    return np.sum((y_true==1)&(y_predict==0))
FN(y_test,y_log_predict)

def TP(y_true,y_predict):
    return np.sum((y_true==1)&(y_predict==1))
TP(y_test,y_log_predict)

 # Постройте матрицу путаницы
def confusion_matrix(y_true,y_predict):
    return np.array([
        [TN(y_true,y_predict),FP(y_true,y_predict)],
        [FN(y_true,y_predict),TP(y_true,y_predict)]
    ])
confusion_matrix(y_test,y_log_predict)

 # Уровень точности
def precision_score(y_true,y_predict):
    tp = TP(y_true,y_predict)
    fp = FP(y_true,y_predict)
    try:
        return tp/(tp+fp)
    except:
        return 0.0
precision_score(y_test,y_log_predict)

 #Recall rate
def recall_score(y_true,y_predict):
    tp = TP(y_true,y_predict)
    fn = FN(y_true,y_predict)
    try:
        return tp/(tp+fn)
    except:
        return 0.0
recall_score(y_test,y_log_predict)

Точность и отзыв в scikitlearn

# Построить матрицу путаницы
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test,y_log_predict)

 # Уровень точности
from sklearn.metrics import precision_score
precision_score(y_test,y_log_predict)

Гармоническое среднее F1_score

Гармоническое среднее имеет следующие основные характеристики:
① На среднее гармоническое значение легко влияют экстремальные значения, и на него больше влияет минимальное значение, чем максимальное значение.
②Пока значение флага равно 0, среднее гармоническое не может быть вычислено.

Позвоните на f1_score в sikit-learn

from sklearn.metrics import f1_score
f1_score(y_test,y_log_predict)
>>> 0.86

Весы Precision-Recall

Вообще говоря, граница принятия решения — это theta.T * x_b = 0, то есть при вычислении p> 0,5 она классифицируется как 1. Если мы вручную изменим этот порог, мы сможем перевести границу принятия решения и изменить точность и скорость отзыва.

# Эта функция может получить прогнозную оценку log_reg без сигмоида
decsion_scores = log_reg.decision_function(X_test)

 # Отрегулируйте порог с 0 по умолчанию до 5
y_predict2 = decsion_scores>=5.0
precision_score(y_test,y_predict2)
>>> 0.96
recall_score(y_test,y_predict2)
>>> 0.5333333333333333

y_predict2 = decsion_scores>=-5.0
precision_score(y_test,y_predict2)
>>> 0.7272727272727273
recall_score(y_test,y_predict2)
>>> 0.8888888888888888

Кривая точности и скорости отзыва

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

from sklearn.metrics import precision_score
from sklearn.metrics import recall_score

thresholds = np.arange(np.min(decsion_scores),np.max(decsion_scores))
precisions = []
recalls = []

for threshold in thresholds:
    y_predict = decsion_scores>=threshold
    precisions.append(precision_score(y_test,y_predict))
    recalls.append(recall_score(y_test,y_predict))

import matplotlib.pyplot as plt

plt.plot(thresholds,precisions)
plt.plot(thresholds,recalls)
plt.show()

plt.plot(precisions,recalls)
plt.show()

Используйте scikit-learn, чтобы нарисовать кривую Precision-Recall

from sklearn.metrics import precision_recall_curve
precisions,recalls,thresholds = precision_recall_curve(y_test,decsion_scores)

# Поскольку точность и отзывчивость на один элемент больше, чем пороговые значения, поэтому, чтобы нарисовать кривую, сначала удалите этот элемент
plt.plot(thresholds,precisions[:-1])
plt.plot(thresholds,recalls[:-1])
plt.show()

Кривая ROC

Кривая ROC используется для описания взаимосвязи между TPR и FPR.

Определение TPR

Определение FPR

Используйте sikit-learn для построения ROC

from sklearn.metrics import roc_curve

fprs,tprs,thresholds = roc_curve(y_test,decsion_scores)
plt.plot(fprs,tprs)

Чем больше площадь, ограниченная кривой ROC, тем лучше модель, но кривая ROC не так чувствительна к искаженным данным, как кривая Precision-Recall.

Проблема множественной классификации

# На этот раз мы используем все данные для решения проблемы множественной классификации логистической регрессии.
X = digits['data']
y = digits['target']
X_train,X_test,y_train,y_test = train_test_split(X,y)

log_reg = LogisticRegression()
log_reg.fit(X_train,y_train)
log_reg.score(X_test,y_test)
>>> 0.9577777777777777

Точность задач множественной классификации в scikit-learn

from sklearn.metrics import precision_score

 #precision_score Сама функция не может вычислять многоклассовые задачи, поэтому необходимо изменить средний параметр
precision_score(y_test,y_predict,average='micro')
>>> 0.9577777777777777

Матрица неточностей для множественных задач классификации

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

from sklearn.metrics import confusion_matrix

confusion_matrix(y_test,y_predict)
>>> array([[30,  0,  0,  0,  0,  0,  0,  1,  0,  0],
       [ 0, 43,  0,  2,  0,  0,  1,  0,  4,  0],
       [ 0,  0, 41,  0,  0,  0,  0,  0,  0,  0],
       [ 0,  0,  0, 47,  0,  0,  0,  0,  0,  1],
       [ 0,  0,  0,  0, 46,  0,  0,  0,  0,  2],
       [ 0,  0,  0,  0,  0, 51,  0,  0,  0,  1],
       [ 0,  0,  0,  0,  0,  0, 38,  0,  1,  0],
       [ 0,  0,  0,  0,  0,  0,  0, 58,  0,  0],
       [ 0,  1,  0,  1,  1,  0,  0,  0, 37,  0],
       [ 0,  1,  0,  1,  0,  0,  0,  0,  1, 40]], dtype=int64)

Постройте матрицу путаницы

cfm = confusion_matrix(y_test,y_predict)
 Параметр #cmap - это набор цветов матрицы рисования, здесь используются оттенки серого.
plt.matshow(cfm,cmap=plt.cm.gray)
plt.show()

Постройте матрицу коэффициента ошибок

# Вычислить общее значение каждой строки
row_sums = np.sum(cfm,axis=1)
err_matrix = cfm/row_sums
 # Установите 0 на диагональ матрицы err_matrix, потому что это правильная часть прогноза, все равно
np.fill_diagonal(err_matrix,0)
err_matrix
>>> array([[0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.01724138, 0.        , 0.        ],
       [0.        , 0.        , 0.        , 0.04166667, 0.        ,
        0.        , 0.02564103, 0.        , 0.1       , 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.        , 0.02325581],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.        , 0.04651163],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.        , 0.02325581],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.025     , 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ,
        0.        , 0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.02      , 0.        , 0.02083333, 0.02083333,
        0.        , 0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.02      , 0.        , 0.02083333, 0.        ,
        0.        , 0.        , 0.        , 0.025     , 0.        ]])

plt.matshow(err_matrix,cmap=plt.cm.gray)
plt.show()