3.4. Метрики и оценка: количественная оценка качества предсказаний

3.4.3.1. Оценщики с именем строки

В большинстве распространенных случаев вы можете назначить объект оценщика параметру scoring с помощью имени строки; таблица ниже показывает все возможные значения. Все объекты оценщиков следуют соглашению, что большие значения возврата лучше, чем меньшие значения возврата. Таким образом, метрики, которые измеряют расстояние между моделью и данными, такие как metrics.mean_squared_error, доступны как ‘neg_mean_squared_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.        ])

3.4.3.2. Вызываемые оценщики

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

• Адаптация предопределённых метрик с помощью make_scorer
• Создание пользовательского объекта оценщика (наиболее гибкий вариант)

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

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

>>> 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.4.4.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.4.4.2. Точность

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

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

Если \(\hat{y}_i\) является предсказанным значением \(i\)-го образца и \(y_i\) — соответствующее истинное значение, то доля правильных предсказаний над \(n_\text{samples}\) определяется как

где \(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.0

В многометковом случае с бинарными индикаторами меток:

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

Примеры

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

3.4.4.3. Точность по лучшим k

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

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

Если \(\hat{f}_{i,j}\) является предсказанным классом для \(i\)-го образца, соответствующего \(j\)-му наибольшему предсказанному значению, и \(y_i\) является соответствующим истинным значением, то доля правильных предсказаний по \(n_\text{samples}\) определяется как

где \(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.4.4.4. Сбалансированная точность

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

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

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

В отличие от этого, если традиционная точность выше случайной только потому, что классификатор использует несбалансированный тестовый набор, то сбалансированная точность, как и ожидается, снизится до \(\frac{1}{n\_classes}\).

Значение показателя варьируется от 0 до 1, или, при использовании adjusted=True, оно масштабируется до диапазона \(\frac{1}{1 - n\_classes}\) до 1 включительно, при случайной производительности, равной 0.

Если \(y_i\) — истинное значение \(i\)-го образца, а \(w_i\) — соответствующий вес образца, то мы корректируем вес образца до:

где \(1(x)\) — индикаторная функция. Учитывая предсказанное значение \(\hat{y}_i\) для образца \(i\), сбалансированная точность определяется как:

При adjusted=True, сбалансированная точность сообщает об относительном увеличении от \(\texttt{сбалансированная-точность}(y, \mathbf{0}, w) = \frac{1}{n\_classes}\). В бинарном случае это также известно как *статистика J Юдена*, или информированность.

Ссылки

3.4.4.5. Коэффициент каппы Коэна

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

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

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

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

3.4.4.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]])

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

Параметр normalize позволяет сообщать отношения вместо подсчётов. Матрица ошибок может быть нормализована тремя способами: '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.4.4.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.4.4.8. Потери Хэмминга

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

Если \(\hat{y}_{i,j}\) — предсказанное значение для \(j\)-й метки заданного образца \(i\), \(y_{i,j}\) — соответствующее истинное значение, \(n_\text{samples}\) — количество образцов, а \(n_\text{labels}\) — количество меток, то потери Хэмминга \(L_{Hamming}\) определяются как:

где \(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

3.4.4.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 определяется как

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

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

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

Обратите внимание, что функция precision_recall_curve ограничена бинарным случаем. Функция average_precision_score поддерживает многоклассовые и многомерные форматы, вычисляя оценку каждого класса по методу «один против остальных» (OvR) и усредняя их, или не усредняя, в зависимости от значения её аргумента average.

Функции PrecisionRecallDisplay.from_estimator и PrecisionRecallDisplay.from_predictions построят кривую точность-полнота следующим образом.

Примеры

• См. Стратегия пересчета сетки поиска с перекрестной проверкой для примера использования precision_score и recall_score для оценки параметров с помощью сетки поиска с вложенной перекрестной проверкой.
• См. Точность-полнота для примера использования precision_recall_curve для оценки качества выходных данных классификатора.

Ссылки

3.4.4.10. Коэффициент сходства Якобши

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

Коэффициент сходства Якобши для набора истинного метки \(y\) и набора предсказанных меток \(\hat{y}\) определяется как

Функция 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="micro")
0.6

В случае многометковой задачи с бинарными индикаторами меток:

>>> 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.4.4.11. Функция потерь Хинджа

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

Если истинная метка \(y_i\) задачи бинарной классификации кодируется как \(y_i=\left\{-1, +1\right\}\) для каждого образца \(i\); и \(w_i\) — соответствующее предсказанное решение (массив формы (n_samples,) в качестве выходного значения метода decision_function), то функция потерь Хинджа определяется как:

Если меток больше двух, функция hinge_loss использует многоклассовую разновидность, предложенную Краммером и Сингером. Здесь описана эта статья.

В этом случае предсказанное решение является массивом формы (n_samples, n_labels). Если \(w_{i, y_i}\) — предсказанное решение для истинной метки \(y_i\) \(i\)-го образца; и \(\hat{w}_{i, y_i} = \max\left\{w_{i, y_j}~|~y_j \ne y_i \right\}\) — максимальное из предсказанных решений для всех остальных меток, то многоклассовая функция потерь Хинджа определяется как:

Вот небольшой пример демонстрирующий использование функции 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=labels)
0.56...

3.4.4.12. Функция потерь логарифма

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

Для задачи бинарной классификации с истинной меткой \(y \in \{0,1\}\) и оценкой вероятности \(p = \operatorname{Pr}(y = 1)\), функция потерь логарифма на один образец равна отрицательному логарифму правдоподобия классификатора при данной истинной метке:

Это обобщается на многоклассовый случай следующим образом. Пусть истинные метки для набора образцов закодированы в виде матрицы бинарных индикаторов 1-из-K \(Y\), т.е., \(y_{i,k} = 1\), если образец \(i\) имеет метку \(k\) из набора из \(K\) меток. Пусть \(P\) — матрица оценок вероятности, где \(p_{i,k} = \operatorname{Pr}(y_{i,k} = 1)\). Тогда функция потерь логарифма для всего набора равна

Чтобы увидеть, как это обобщает бинарную функцию потерь логарифма, указанную выше, обратите внимание, что в бинарном случае, \(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.4.4.13. Коэффициент корреляции Маттьюза

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

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

В бинарном (двухклассовом) случае, где \(tp\), \(tn\), \(fp\) и \(fn\) соответственно обозначают количество истинных положительных, истинных отрицательных, ложных положительных и ложных отрицательных результатов, MCC определяется как

В случае многоклассовой классификации коэффициент корреляции Маттьюза может быть определён через матрицу 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 больше не будет находиться в диапазоне от -1 до +1. Вместо этого минимальное значение будет где-то между -1 и 0, в зависимости от количества и распределения истинных меток. Максимальное значение всегда равно +1. Для дополнительной информации см. [WikipediaMCC2021].

Вот небольшой пример, иллюстрирующий использование функции 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.4.4.14. Матрица неразделённой путаницы для множественных меток

Функция multilabel_confusion_matrix вычисляет матрицу неразделённой путаницы для отдельных классов (по умолчанию) или для отдельных образцов (samplewise=True), чтобы оценить точность классификации. 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.4.4.15. Кривая ROC (Receiver Operating Characteristic)

Функция roc_curve вычисляет кривую ROC (Receiver Operating Characteristic). Цитата из Википедии:

«Кривая ROC (Receiver Operating Characteristic), или просто кривая ROC, представляет собой графическое изображение, которое иллюстрирует работу системы бинарной классификации при изменении порога дискриминации. Она создаётся путём построения графика доли истинных положительных результатов из положительных (чувствительность, TPR = true positive rate) против доли ложных положительных результатов из отрицательных (специфичность, FPR = false positive rate) при различных значениях порога. 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([ inf, 0.8 , 0.4 , 0.35, 0.1 ])

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

Функция roc_auc_score, обозначаемая ROC-AUC или AUROC, вычисляет площадь под кривой ROC. Таким образом, информация с кривой сводится к одному числу.

На следующем рисунке показана кривая ROC и значение ROC-AUC для классификатора, предназначенного для различения цветка virginica от остальных видов в наборе данных о растениях Ирис:

Дополнительную информацию можно найти в статье Википедии об AUC.

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

>>> 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.4.4.15.2. Многоклассовый случай

Функция roc_auc_score также может быть использована в многоклассовой классификации. В настоящее время поддерживаются две стратегии усреднения: алгоритм один-против-всех вычисляет среднее значение парных значений ROC AUC, а алгоритм один-против-остальных вычисляет среднее значение значений 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'.

Метрика многоклассового AUC [HT2001] может быть расширена до взвешивания по распространённости:

\[\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'. Кроме 'macro' [F2006] и 'weighted' [F2001] усреднения, OvR поддерживает 'micro' усреднение.

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

На следующем рисунке показана кривая ROC с микроусреднением и соответствующее значение ROC-AUC для классификатора, предназначенного для различения разных видов в наборе данных о растениях Ирис:

3.4.4.16. Торговля ошибками обнаружения (DET)

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

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

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

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

Примеры

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

Ссылки

3.4.4.17. Потеря 0-1

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

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

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

где \(1(x)\) — индикаторная функция. Потеря 0-1 также может быть вычислена как \(zero-one loss = 1 - accuracy\).

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

В случае многоклассовой классификации с бинарными индикаторами меток, где первая метка [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.0

Примеры

• См. Рекурсивное исключение признаков с перекрестной проверкой для примера использования потери 0-1 для выполнения рекурсивного исключения признаков с перекрестной проверкой.

3.4.4.18. Потеря по методу Бриера

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

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

Эта функция возвращает среднеквадратическую ошибку фактического результата \(y \in \{0,1\}\) и оценённой вероятности предсказания \(p = \operatorname{Pr}(y = 1)\) (predict_proba) в качестве выходных данных, как выведено ниже:

Потеря Бриера также лежит в пределах от 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].

Примеры

• См. Калибровка вероятностей классификаторов для примера использования потери Бриера для выполнения калибровки вероятностей классификаторов.

Литература

3.4.4.19. Отношения правдоподобия классов

Функция class_likelihood_ratios вычисляет положительные и отрицательные отношения правдоподобия \(LR_\pm\) для бинарных классов, которые можно интерпретировать как отношение шансов после теста к шансам до теста, как описано ниже. Вследствие этого, этот показатель инвариантен к распространённости классов (количество образцов в положительном классе, делённое на общее количество образцов) и можно экстраполировать между популяциями независимо от возможного дисбаланса классов.

Метрики \(LR_\pm\) поэтому очень полезны в ситуациях, где доступные данные для обучения и оценки классификатора — это популяция исследования с почти сбалансированными классами, например, исследование случая-контроля, в то время как целевая область применения, т.е. общая популяция, имеет очень низкую распространённость.

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

Здесь обозначение относится к предсказанной (\(P\)) или истинной (\(T\)) метке, а знак \(+\) и \(-\) относятся к положительному и отрицательному классу соответственно, например, \(P+\) обозначает «предсказанный положительный».

Аналогично, отрицательное отношение правдоподобия \(LR_-\) — это вероятность того, что образец положительного класса будет классифицирован как принадлежащий к отрицательному классу, делённая на вероятность того, что образец отрицательного класса будет правильно классифицирован:

Для классификаторов, превосходящих случайность, \(LR_+\) выше 1 лучше, в то время как \(LR_-\) колеблется от 0 до 1 и лучше ниже. Значения \(LR_\pm\approx 1\) соответствуют уровню случайности.

Обратите внимание, что вероятности отличаются от счётов, например, \(\operatorname{PR}(P+|T+)\) не равно количеству истинных положительных счётов tp (см. страницу Википедии для фактических формул).

Примеры

• Отношения правдоподобия классов для измерения производительности классификации

3.4.4.20. Метрика D² для классификации

Метрика D² вычисляет долю объяснённого отклонения. Это обобщение R², где среднеквадратическая ошибка обобщена и заменена выбором отклонения классификации \(\text{dev}(y, \hat{y})\) (например, логарифмическая потеря). D² — это форма балльной оценки. Она рассчитывается как

Где \(y_{\text{null}}\) — оптимальное предсказание модели только с константой (например, доля на класс y_true в случае логарифмической потери).

Как и R², наилучший возможный балл — 1,0, и он может быть отрицательным (потому что модель может быть произвольно хуже). Модель с постоянным предсказанием \(y_{\text{null}}\), игнорирующая входные данные, получила бы балл D² 0,0.

>>> from sklearn.metrics import d2_log_loss_score
>>> y_true = [1, 1, 2, 3]
>>> y_pred = [
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
...    [0.5, 0.25, 0.25],
... ]
>>> d2_log_loss_score(y_true, y_pred)
0.0
>>> y_true = [1, 2, 3]
>>> y_pred = [
...     [0.98, 0.01, 0.01],
...     [0.01, 0.98, 0.01],
...     [0.01, 0.01, 0.98],
... ]
>>> d2_log_loss_score(y_true, y_pred)
0.981...
>>> y_true = [1, 2, 3]
>>> y_pred = [
...     [0.1, 0.6, 0.3],
...     [0.1, 0.6, 0.3],
...     [0.4, 0.5, 0.1],
... ]
>>> d2_log_loss_score(y_true, y_pred)
-0.552...

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

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

Формально, для данной бинарной матрицы индикаторов истинных меток \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) и оценки, связанной с каждой меткой \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), покрытие определяется как

где \(\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.4.5.2. Средняя точность ранжирования меток

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

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

Формально, для данной бинарной матрицы индикаторов истинных меток \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) и оценки, связанной с каждой меткой \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), средняя точность определяется как

где \(\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\) (которая вычисляет число ненулевых элементов в векторе).

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

>>> 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.4.5.3. Потеря ранжирования

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

Формально, для данной бинарной матрицы индикаторов истинных меток \(y \in \left\{0, 1\right\}^{n_\text{samples} \times n_\text{labels}}\) и оценки, связанной с каждой меткой \(\hat{f} \in \mathbb{R}^{n_\text{samples} \times n_\text{labels}}\), потеря ранжирования определяется как

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

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

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

3.4.5.4. Нормализованный дисконтированный кумулятивный выигрыш

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

Из страницы Википедии по дисконтированному кумулятивному выигрышу:

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

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

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

Для одного образца, заданного вектором непрерывных истинных значений для каждой цели \(y \in \mathbb{R}^{M}\), где \(M\) — число выходов, и предсказанием \(\hat{y}\), которое индуцирует функцию ранжирования \(f\), оценка DCG равна

и оценка NDCG равна оценке DCG, делённой на оценку DCG, полученную для \(y\).

3.4.6.1. Коэффициент детерминации R²

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

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

Так как дисперсия зависит от набора данных, \(R^2\) может быть не сопоставим по смыслу для разных наборов данных. Лучшее возможное значение равно 1,0, и оно может быть отрицательным (потому что модель может быть произвольно хуже). Модель, которая всегда предсказывает ожидаемое (среднее) значение y, игнорируя входные признаки, получит значение \(R^2\) равное 0,0.

Примечание: когда остатки прогноза имеют нулевое среднее, коэффициент \(R^2\) и Оценка дисперсии совпадают.

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение для общего \(n\) выборок, то оценка \(R^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^2\) без коррекции смещения в выборочной дисперсии y.

В частности, если истинное значение цели постоянно, то значение \(R^2\) не является конечным: оно равно NaN (идеальные прогнозы) или -Inf (неидеальные прогнозы). Такие бесконечные значения могут предотвратить правильную оптимизацию модели, например, при выполнении поиска по сетке с перекрестной проверкой. По этой причине по умолчанию r2_score заменяет их на 1,0 (идеальные прогнозы) или 0,0 (неидеальные прогнозы). Если force_finite установлено в False, эта оценка возвращается к исходному определению \(R^2\).

Вот небольшой пример использования функции 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...
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2]
>>> r2_score(y_true, y_pred)
1.0
>>> r2_score(y_true, y_pred, force_finite=False)
nan
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2 + 1e-8]
>>> r2_score(y_true, y_pred)
0.0
>>> r2_score(y_true, y_pred, force_finite=False)
-inf

Примеры

• См. Модели на основе L1 для разреженных сигналов для примера использования R² оценки для оценки моделей Лассо и Эластичного сета на разреженных сигналах.

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

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение, то средняя абсолютная ошибка (MAE) вычисляется по \(n_{\text{samples}}\) выборкам как

Вот небольшой пример использования функции 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.4.6.3. Средняя квадратичная ошибка

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение, то средняя квадратичная ошибка (MSE) вычисляется по \(n_{\text{samples}}\) выборкам как

Вот небольшой пример использования функции 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...

Примеры

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

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

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

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение, то среднеквадратичная логарифмическая ошибка (MSLE), вычисленная по \(n_{\text{samples}}\), определяется как

Где \(\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...

Корень из среднеквадратичной логарифмической ошибки (RMSLE) доступен через функцию root_mean_squared_log_error.

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

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение, то средняя абсолютная процентная ошибка (MAPE) по \(n_{\text{samples}}\) определяется следующим образом:

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

Функция mean_absolute_percentage_error поддерживает многовыходные данные.

Вот небольшой пример использования функции 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.4.6.6. Медиана абсолютной ошибки

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(y_i\) — соответствующее истинное значение, то медианная абсолютная ошибка (MedAE) по \(n_{\text{samples}}\) определяется следующим образом:

Функция median_absolute_error не поддерживает многовыходные данные.

Вот небольшой пример использования функции 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.4.6.7. Максимальная ошибка

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

Если \(\hat{y}_i\) — предсказанное значение \(i\)-й выборки, а \(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 не поддерживает многовыходные данные.

3.4.6.8. Метрика объяснённой дисперсии

Функция explained_variance_score вычисляет метрику объяснённой дисперсии регрессии.

Если \(\hat{y}\) — оценённое значение целевого выхода, \(y\) — соответствующее (правильное) значение целевого выхода, а Var — дисперсия, то объяснённая дисперсия оценивается следующим образом:

Наилучшее возможное значение равно 1,0. Более низкие значения указывают на худшие результаты.

В случае, когда истинное целевое значение постоянно, значение метрики объяснённой дисперсии не является конечным: оно равно либо NaN (идеальные предсказания), либо -Inf (неидеальные предсказания). Такие бесконечные значения могут помешать корректной оптимизации модели, например, при использовании перекрёстной проверки с подбором сетки. Поэтому по умолчанию explained_variance_score заменяет их на 1,0 (идеальные предсказания) или 0,0 (неидеальные предсказания). Можно установить параметр force_finite на значение False для предотвращения этой фиксации и возврата к исходному значению метрики объяснённой дисперсии.

Вот небольшой пример использования функции 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...
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2]
>>> explained_variance_score(y_true, y_pred)
1.0
>>> explained_variance_score(y_true, y_pred, force_finite=False)
nan
>>> y_true = [-2, -2, -2]
>>> y_pred = [-2, -2, -2 + 1e-8]
>>> explained_variance_score(y_true, y_pred)
0.0
>>> explained_variance_score(y_true, y_pred, force_finite=False)
-inf

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

Функция mean_tweedie_deviance вычисляет среднее отклонение Твидди с параметром 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_{\text{samples}}\), определяется как

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

Например, давайте сравним два предсказания 1,5 и 150, которые оба на 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...

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

3.4.6.10. Потеря в виде пинболла

Функция mean_pinball_loss используется для оценки производительности предсказаний моделей квантильной регрессии.

Значение потери в виде пинболла эквивалентно половине mean_absolute_error, когда параметр квантиля alpha установлен в 0,5.

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

>>> from sklearn.metrics import mean_pinball_loss
>>> y_true = [1, 2, 3]
>>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.1)
0.03...
>>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.1)
0.3...
>>> mean_pinball_loss(y_true, [0, 2, 3], alpha=0.9)
0.3...
>>> mean_pinball_loss(y_true, [1, 2, 4], alpha=0.9)
0.03...
>>> mean_pinball_loss(y_true, y_true, alpha=0.1)
0.0
>>> mean_pinball_loss(y_true, y_true, alpha=0.9)
0.0

Возможна постройка объекта-оценщика со специфическим выбором alpha:

>>> from sklearn.metrics import make_scorer
>>> mean_pinball_loss_95p = make_scorer(mean_pinball_loss, alpha=0.95)

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

>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import cross_val_score
>>> from sklearn.ensemble import GradientBoostingRegressor
>>>
>>> X, y = make_regression(n_samples=100, random_state=0)
>>> estimator = GradientBoostingRegressor(
...     loss="quantile",
...     alpha=0.95,
...     random_state=0,
... )
>>> cross_val_score(estimator, X, y, cv=5, scoring=mean_pinball_loss_95p)
array([13.6..., 9.7..., 23.3..., 9.5..., 10.4...])

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

Примеры

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

3.4.6.11. Балл D²

Балл D² вычисляет долю объяснённой дисперсии. Это обобщение R², где среднеквадратическая ошибка обобщена и заменена выбранной дисперсией \(\text{dev}(y, \hat{y})\) (например, Tweedie, pinball или средняя абсолютная ошибка). D² — это разновидность баллов умения. Он вычисляется как

Где \(y_{\text{null}}\) — оптимальное предсказание модели только с перехватом (например, среднее значение y_true для случая Tweedie, медиана для абсолютной ошибки и альфа-квантиль для потери pinball).

Как и R², наилучший возможный балл равен 1,0, и он может быть отрицательным (потому что модель может быть произвольно хуже). Модель постоянного значения, которая всегда предсказывает \(y_{\text{null}}\), игнорируя входные признаки, получит балл D² равный 0,0.

>>> from sklearn.metrics import d2_tweedie_score, make_scorer
>>> d2_tweedie_score_15 = make_scorer(d2_tweedie_score, power=1.5)

>>> from sklearn.metrics import d2_pinball_score, make_scorer
>>> d2_pinball_score_08 = make_scorer(d2_pinball_score, alpha=0.8)

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

3.4.6.12. Визуальная оценка моделей регрессии

Среди методов оценки качества моделей регрессии scikit-learn предоставляет класс PredictionErrorDisplay. Он позволяет визуально просмотреть ошибки предсказания модели двумя разными способами.

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

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

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

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

Диаграмма справа показывает остатки (т.е. разницу между фактическими и предсказанными значениями) по отношению к предсказанным значениям.

Это график облегчает визуализацию, если остатки следуют и гомоскедастическому или гетероскедастическому распределению.

В частности, если истинное распределение y|X имеет распределение Пуассона или Гамма, ожидается, что дисперсия остатков оптимальной модели будет расти с предсказанным значением E[y|X] (линейно для Пуассона или квадратично для Гамма).

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

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

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

Примеры

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