Лекція 05 · Класифікація та логістична регресія

У попередніх лекціях модель передбачала число. Тепер вона має відповісти на питання іншого типу: до якого класу належить об'єкт. Розберемо це на реальних медичних даних — 569 пухлин молочної залози, для кожної треба вирішити, доброякісна вона чи злоякісна.

Зміст лекції

Лекція побудована як один наскрізний шлях від задачі до працюючої моделі та її оцінювання.

1. Задача класифікації. Чим категоріальна мітка відрізняється від числової і що таке межа рішення.
2. Чому лінійна регресія тут не працює. Три конкретні поломки і функції втрат, придатні для класифікації.
3. Логістична регресія. Ланцюжок «ймовірність → шанси → логарифм шансів → лінійна модель» і сигмоїда.
4. Навчання моделі. Перехресна ентропія з принципу максимальної правдоподібності, градієнт, градієнтний спуск.
5. Оцінювання якості. Матриця похибок, точність і повнота, поріг, ROC-крива й AUC як частка правильно впорядкованих пар, крива точність–повнота.
6. Дисбаланс класів. Метрики для рідкісного класу, поріг за ціною помилок, ваги класів, передискретизація і SMOTE, недодискретизація, фокальна втрата (focal loss) — і порівняння всіх способів на одних даних.
7. Чесні ймовірності. Крива калібрування і міра Брайєра, як зважування класів псує ймовірності і як метод Платта та ізотонічна регресія їх лагодять.
8. Мультиклас. One-vs-rest і softmax як узагальнення на кілька класів.

Кожен наступний блок спирається на попередній: спершу з'ясуємо, чому потрібна нова модель, потім побудуємо її, навчимо і лише тоді навчимося вимірювати, наскільки вона добра.

Чого ви навчитеся

Після цієї лекції ви зможете:

• назвати три причини, чому лінійна регресія з порогом погано розв'язує задачу класифікації;
• пояснити ланцюжок «ймовірність → шанси → логарифм шансів» і роль сигмоїди в ньому;
• пояснити, звідки береться перехресна ентропія: з принципу максимальної правдоподібності для розподілу Бернуллі;
• записати градієнт логістичної регресії і пояснити, чому він має той самий вигляд, що в методі найменших квадратів;
• побудувати матрицю похибок, ROC-криву і криву точність–повнота, прочитати їх і пояснити AUC як частку правильно впорядкованих пар;
• обрати поріг класифікації, виходячи з ціни помилки, а не за замовчуванням 0,5;
• обрати метрику для незбалансованих класів (Fβ, MCC, збалансована частка правильних, AP) і обчислити поріг за ціною помилок;
• пояснити, що змінюють ваги класів, SMOTE, недодискретизація і фокальна втрата, і порівняти їх на даних;
• перевірити калібрування кривою і мірою Брайєра та відкалібрувати модель методом Платта;
• розрізнити one-vs-rest і softmax та обрати підхід для задачі з кількома класами.

Задача: коли відповідь категоріальна

Лікар вирішує, чи є пухлина злоякісною. Банк вирішує, чи є транзакція шахрайською. Поштовий сервер вирішує, чи є лист спамом. У всіх трьох випадках відповідь не число, а одна з кількох категорій, і між категоріями немає природного порядку: «шахрайство» не більше і не менше за «норму».

Класифікація (classification) пов'язує вхід із категоріальною міткою: за новим спостереженням $x$ потрібно передбачити його клас $y$. Якщо класів два, задачу називають бінарною; якщо більше — багатокласовою.

"Classification relates input to a categorical variable. Goal: given a new observation x, we want to predict its label y." — EPFL CS-433, лекція 05a

Джерело: EPFL CS-433 Machine Learning

Дані лекції: діагностика пухлин молочної залози

Увесь курс лекції побудований на одному наборі даних, щоб було видно повний шлях від сирих чисел до рішення.

Breast Cancer Wisconsin (Diagnostic). 569 спостережень, 30 числових ознак. Ознаки обчислені з оцифрованого зображення пункційної біопсії: радіус, текстура, периметр, площа ядер клітин, симетрія, кількість увігнутих точок контуру та інші. Передбачаємо діагноз: доброякісна пухлина чи злоякісна.

Класи незбалансовані — доброякісних майже вдвічі більше. Це знадобиться, коли дійдемо до метрик якості.

Ліворуч — скільки пухлин кожного класу, праворуч — розподіл середнього радіуса ядра в кожному класі.

Джерело даних: UCI Machine Learning Repository

Матеріали до розділу

• 📊UCI · Breast Cancer Wisconsin (Diagnostic)дані

  Первинне джерело набору з описом того, як вимірювали кожну з 30 ознак.

• ⚙scikit-learn · опис набору Breast Cancerдокументація

  Перелік усіх 30 ознак із поясненням, що саме вимірювали на зображенні клітинного ядра.

Двох ознак із тридцяти вже майже досить

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

Злоякісні пухлини зосереджені вгорі праворуч — вони більші й мають порізаніший контур. Класи майже розділяються прямою лінією, і саме цю лінію шукатиме логістична регресія. «Майже» тут ключове слово: в зоні перекриття лежать пацієнтки, щодо яких будь-яка модель буде невпевнена, і далі ми побачимо, що з цією невпевненістю робити.

569 пухлин у координатах двох ознак; синім — доброякісні, червоним — злоякісні.

Класифікатор ділить простір ознак на регіони

Класифікатор $f:\mathcal{X}\to \mathcal{Y}$ розбиває простір ознак на регіони — по одному на клас. Поверхня, що розділяє ці регіони, називається межею рішення (decision boundary). Форма межі — це і є те, чим відрізняються методи класифікації між собою: логістична регресія проводить пряму, дерево рішень — сходинки, метод k найближчих сусідів — ламану, що повторює форму даних.

На рисунку нижче десять різних класифікаторів працюють на трьох однакових наборах даних. Логістичної регресії серед них немає, але лінійна SVM (Linear SVM) проводить таку саму пряму межу. Видно головне: універсального методу немає, форма межі має відповідати формі даних.

Англійські підписи: Nearest Neighbors — k найближчих сусідів, Linear SVM і RBF SVM — метод опорних векторів з лінійним і RBF-ядром, Decision Tree — дерево рішень, Random Forest — випадковий ліс, Neural Net — нейронна мережа, Naive Bayes — наївний Баєс, QDA — квадратичний дискримінантний аналіз; число в куті — частка правильних відповідей на тесті.

Джерело: scikit-learn · Classifier comparison

Спроба перша: лінійна регресія з порогом

Мітки 0 і 1 — теж числа. Найпростіша ідея: навчити звичайну лінійну регресію і оголосити клас 1 там, де прогноз перевищує 0,5.

Ліворуч видно першу поломку: прогноз лінійної моделі виходить за межі відрізка $[0,1]$, тобто його не можна читати як імовірність. Праворуч — друга поломка: додали 25 пухлин із дуже великим радіусом, усі злоякісні. Це «занадто правильні» спостереження, модель і без них ставила їм клас 1. Проте пряма розвернулася, і поріг лінійної моделі поїхав з 15,4 до 17,6 — тепер частина злоякісних пухлин потрапляє в доброякісні. Логістична регресія, яку ми збудуємо нижче, на тих самих даних не зрушила з місця: її поріг лишився 14,8.

Сірі точки — пацієнтки (0 — доброякісна, 1 — злоякісна), червоні — 25 доданих дуже великих пухлин; пунктир — поріг кожної моделі.

Квадратична втрата карає впевненість

Третя поломка — і корінь двох перших — у функції втрат. Нехай істинна мітка $y=+1$, а модель видає число $o$. Квадратична втрата $(o-1{)}^2$ не розрізняє «трохи помилився» і «мав рацію, але надто впевнено».

Прогноз $o$	Мітка $y$	Втрата $(o-1{)}^2$	Як це читати
0,9	+1	0,01	розсудливо і правильно
−0,8	+1	3,24	помилка, штраф доречний
100	+1	9801	правильно й дуже впевнено — а штраф найбільший

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

Джерело числового прикладу: UBC CPSC 340, лекція 18

Функції втрат, придатні для класифікації

Що ми насправді хочемо мінімізувати — це частку помилок, тобто нуль-одиничну втрату (zero-one loss). Вона розривна й неопукла, тому напряму мінімізувати її неможливо. Замість неї беруть опуклу сурогатну втрату (surrogate loss), яка з точністю до сталого множника не нижча за нуль-одиничну, тобто є верхньою оцінкою частки помилок: зменшуючи її, ми опускаємо цю оцінку.

Усі такі втрати зручно записати через одну величину. Нехай $g(x)=x^{\mathrm{\top }}w+w_0$ — сирий вихід лінійної моделі, а мітки закодовано як $y\in \{-1,+1\}$. Функційний відступ (margin) $m=y\cdot g(x)$ додатний, коли знак виходу збігся з міткою, тобто клас угадано, а його модуль показує, наскільки впевнено.

У клітинках — значення втрати для двох прикладів відступу; це не мітки класів.

Втрата	Формула	втрата при $m=2$ (клас угадано впевнено)	втрата при $m=-1$ (помилка)
нуль-одинична	$\mathbb{1}[m\le 0]$	0 — помилки немає	1 — помилка
логістична	$\log (1+e^{-m})$	0,127	1,313
hinge	$max(0,1-m)$	0	2
квадратична	$(1-m{)}^2$	1	4

Тут $\mathbb{1}[\cdot ]$ дорівнює 1, коли умова в дужках виконується, і 0 інакше; $\log$ — натуральний логарифм. Одиниця в hinge — бажаний запас відступу: щойно $m\ge 1$, штраф зникає.

При $m=2$ відповідь правильна й упевнена: логістична втрата майже нуль, hinge — рівно нуль, а квадратична штрафує на 1. При $m=-1$ модель помилилася, і штрафують усі чотири. Логістична спадає монотонно й ніколи не зростає назад; квадратична праворуч від $m=1$ знову росте — це та сама кара за впевненість із попереднього розділу. Нижче побачимо, що логістична втрата — це перехресна ентропія, записана через відступ.

Вертикальні пунктири — відступи 2 і −1 із таблиці. У нулі логістична втрата дорівнює log 2 ≈ 0,693: стільки ж дає модель, яка всім ставить імовірність 0,5.

Логістична втрата веде до логістичної регресії, hinge — до методу опорних векторів, який розберемо в лекції 07. Віджет нижче рахує всі чотири втрати для будь-якого відступу.

Чотири втрати для одного відступу

Відступ m = y·g(x) додатний, коли клас угадано, а його модуль — упевненість. Посуньте повзунок і подивіться, яка втрата скільки штрафує.

Відступ m = 2,00

втрата	формула	значення втрати при m = 2,00
нуль-одинична	𝟙[m ≤ 0]	0,000
логістична	log(1 + e⁻ᵐ)	0,127
hinge	max(0, 1 − m)	0,000
квадратична	(1 − m)²	1,000

Поставте m = 2: відповідь правильна й упевнена, логістична втрата майже нуль (0,127), hinge — рівно нуль, а квадратична все одно штрафує на 1. Далі праворуч квадратична тільки росте — вона карає модель за зайву впевненість. При m = −1 модель помилилася, і штрафують усі чотири. На самій межі, m = 0, логістична втрата дорівнює log 2 ≈ 0,693 — тій самій втраті, з якої починає спуск у коді «з нуля», коли всім приписано ймовірність 0,5.

Від імовірності до необмеженої шкали

Лінійна модель $x^{\mathrm{\top }}w+w_0$ дає будь-яке дійсне число, а ймовірність зобов'язана лежати в $[0,1]$. Замість того щоб калічити лінійну модель, розтягнемо ймовірність на всю пряму — у два кроки.

Шанси (odds) ${\displaystyle \frac{p}{1-p}}$ переводять $(0,1)$ у $(0,\mathrm{\infty })$: ймовірності 0,5 відповідають шанси 1, ймовірності 0,9 — шанси 9 (дев'ять до одного).

Логарифм переводить додатні шанси, тобто інтервал $(0,\mathrm{\infty })$, у всю числову пряму. Разом два кроки дають логарифм шансів (log-odds), або логіт: $\log {\displaystyle \frac{p}{1-p}}$ переводить $(0,1)$ у всю пряму. Для $p=0,9$ логіт дорівнює $\log 9\approx \mathrm{2,197}$. Кінці інтервалу відкриті навмисно: при $p=0$ логіт дорівнює мінус нескінченності, при $p=1$ — плюс нескінченності, тобто скінченна модель туди не потрапляє.

Тепер лінійна модель і величина, яку вона моделює, живуть на одній шкалі:

$$\log \frac{p}{1-p}=x^{\mathrm{\top }}w+w_0$$

"Trick: don't deal with probabilities ∈ [0,1], but with log odds ∈ ]−∞,∞[." — EPFL CS-433, лекція 05b

Сигмоїда повертає нас до ймовірності

Розв'язавши рівняння логіта відносно $p$, отримуємо логістичну функцію, або сигмоїду (sigmoid):

$$\sigma (z)=\frac{1}{1+e^{-z}}$$

Позначення	Значення
$z=x^{\mathrm{\top }}w+w_0$	лінійна комбінація ознак, логарифм шансів
$\sigma (z)\in (0,1)$	ймовірність класу 1
$1-\sigma (z)=\sigma (-z)$	ймовірність класу 0
${\sigma }^{\prime }(z)=\sigma (z)(1-\sigma (z))$	похідна, знадобиться в градієнті

Сигмоїда монотонна, гладка і симетрична відносно точки $(0;0,5)$: нулю логіта відповідає ймовірність рівно одна друга. Наприклад, $\sigma (2)=1/(1+e^{-2})\approx \mathrm{0,881}$, а $\sigma (-2)\approx \mathrm{0,119}$ — рівно стільки ж по інший бік від 0,5.

Джерело: Stanford CS231n · Neural Networks

Модель логістичної регресії

Складаємо все разом. Логістична регресія (logistic regression) задає ймовірність класу так:

$$p(y=1\mid x)=\sigma (x^{\mathrm{\top }}w+w_0),p(y=0\mid x)=1-p(y=1\mid x)$$

Клас 1 обирають, коли $p(y=1\mid x)\ge \frac{1}{2}$. Оскільки $\sigma (z)\ge \frac{1}{2}$ рівно тоді, коли $z\ge 0$, для самого прогнозу класу важливий лише знак $x^{\mathrm{\top }}w+w_0$. Поріг 0,5 у просторі ймовірностей — це поріг нуль у лінійному просторі.

Попри назву, логістична регресія — метод класифікації. Назва історична: регресією тут є моделювання логарифма шансів.

Геометрія: напрям вектора ваг і впевненість

Три властивості моделі, які варто бачити очима.

Межа рішення — гіперплощина $x^{\mathrm{\top }}w+w_0=0$. У двох вимірах це пряма, у трьох — площина.

Вектор $w$ ортогональний до межі і вказує напрям найшвидшого зростання ймовірності. Його довжина визначає крутість переходу: $x^{\mathrm{\top }}w+w_0=\parallel w\parallel \cdot d(x)$, де $d(x)$ — відстань зі знаком від точки до межі, тож $p=\sigma (\parallel w\parallel d)$. Точка на відстані 1 від межі при $\parallel w\parallel =1$ отримує ймовірність 0,731, а при $\parallel w\parallel =5$ — уже 0,993.

Перевіримо це на моделі з рисунка: логістична регресія на двох стандартизованих ознаках — радіусі й увігнутих точках, — навчена на 398 пацієнтках навчальної частини.

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
col = list(data.feature_names).index
X2 = data.data[:, [col("mean radius"), col("mean concave points")]]
y2 = (data.target == 0).astype(int)  # 1 = злоякісна
split = train_test_split(X2, y2, test_size=0.3, stratify=y2, random_state=0)
X_tr, X_te, y_tr, y_te = split
sc = StandardScaler().fit(X_tr)  # стандартизація за навчальною частиною
geo = LogisticRegression().fit(sc.transform(X_tr), y_tr)
w, w0 = geo.coef_[0], geo.intercept_[0]
norm = np.linalg.norm(w)
print(f"w = ({w[0]:.3f}; {w[1]:.3f}), w0 = {w0:.3f}, ‖w‖ = {norm:.3f}")
A, B = (np.array([x1, -(w0 + w[0] * x1) / w[1]]) for x1 in (-1.0, 1.0))  # точки межі
print(f"A = ({A[0]:.3f}; {A[1]:.3f}), B = ({B[0]:.3f}; {B[1]:.3f})", end="")
print(f", w·(B − A) = {w @ (B - A):.1e}")
x = sc.transform(X_te[[127]])[0]  # пацієнтка, позначена на рисунку
g = w @ x + w0
print(f"пацієнтка: g(x) = {g:.3f}, d = {g / norm:.3f}, p = {1 / (1 + np.exp(-g)):.3f}")
print(f"на відстані d = 0,5 від межі: p = {1 / (1 + np.exp(-0.5 * norm)):.3f}")

Вивід код запущено, вивід не редагувався

w = (1.808; 3.323), w0 = -0.389, ‖w‖ = 3.783
A = (-1.000; 0.661), B = (1.000; -0.427), w·(B − A) = 0.0e+00
пацієнтка: g(x) = 2.744, d = 0.725, p = 0.940
на відстані d = 0,5 від межі: p = 0.869

На що дивитися: w = (1,808; 3,323) і w₀ = −0,389 задають межу 1,808·x₁ + 3,323·x₂ − 0,389 = 0; добуток w·(B − A) дорівнює нулю — w перпендикулярний межі; вибрана пацієнтка лежить на відстані 0,725 від межі й отримує p = 0,940.

Звідки перпендикулярність. Межа — це множина точок, де $g(x)=w^{\mathrm{\top }}x+w_0=0$. Візьмімо на ній дві точки з виводу, $A=(-1;\mathrm{0,661})$ і $B=(1;-\mathrm{0,427})$: вектор $B-A$ лежить уздовж межі. Оскільки в обох точках $w\cdot x=-w_0$,

$$w\cdot (B-A)=w\cdot B-w\cdot A=(-w_0)-(-w_0)=0,$$

і код показує це числом: добуток дорівнює нулю з точністю до похибки округлення. Отже, $w$ перпендикулярний межі, а вказує туди, де $g(x)$ зростає, — до злоякісних.

Пацієнтка, позначена на рисунку, лежить по злоякісний бік: $g(x)=\mathrm{2,744}$, відстань до межі $d=\mathrm{2,744}/\mathrm{3,783}=\mathrm{0,725}$, і модель дає їй $p=\sigma (\mathrm{2,744})=\mathrm{0,940}$. Для нашої моделі $\parallel w\parallel =\mathrm{3,783}$, тож уже на відстані 0,5 стандартної одиниці від межі ймовірність дорівнює 0,869.

Модуль $|x^{\mathrm{\top }}w+w_0|$ — це впевненість. Далеко від межі ймовірності близькі до 0 або 1, поряд із межею — близькі до 0,5. Саме тому модель віддає не лише клас, а й міру сумніву, і це головна її перевага перед простим правилом «так або ні».

На рисунку ліворуч — дискретне рішення, праворуч — неперервна карта ймовірності тієї самої моделі. У віджеті під рисунком можна пройти весь ланцюжок «відстань → логіт → шанси → імовірність» і змінити $\parallel w\parallel$.

Модель на двох стандартизованих ознаках — радіусі й увігнутих точках; показано всіх 569 пацієнток. Чорна лінія — межа, де ймовірність дорівнює 0,5; стрілка — напрям вектора w (довжину вкорочено), пунктир — перпендикуляр від вибраної пацієнтки до межі.

Від відстані до ймовірності

Точка на відстані d від межі отримує логіт z = ‖w‖·d, шанси e^z й імовірність σ(z). Логарифм шансів повертає назад той самий z.

Відстань до межі d = 2,00Довжина вектора ваг ‖w‖ = 1,00

2,000логіт z = ‖w‖·d

7,389шанси e^z = p/(1 − p)

0,881імовірність p = σ(z)

2,000log(p/(1 − p)) — знову z

Сіра крива — ‖w‖ = 1, синя — поточна довжина. Натисніть «p = 0,9»: шанси дорівнюють 9, а логіт — log 9 = 2,197. «z = 2» і «z = −2» дають 0,881 і 0,119 — симетрично відносно 0,5. Тепер лишіть d = 1 і збільшуйте ‖w‖: при ‖w‖ = 1 точка отримує 0,731, при ‖w‖ = 5 — уже 0,993. Межа рішення (d = 0) при цьому не рухається: довжина вектора ваг змінює лише те, як різко модель перемикається з «ні» на «так», тобто її впевненість. Остання кнопка ставить довжину вектора ваг нашої моделі з рисунка, 3,783: уже на відстані 0,5 від межі ймовірність 0,869.

Максимальна правдоподібність задає функцію втрат

У лекції 04 ми бачили загальний принцип: обираємо параметри, за яких спостережені дані найімовірніші. Мітка тут приймає два значення, тому природна модель — розподіл Бернуллі з параметром $p_n=\sigma (x_n^{\mathrm{\top }}w)$. Якщо спостереження незалежні — а це окреме припущення, — правдоподібність вибірки дорівнює добутку:

$$\mathcal{L}(w)\propto \prod _{n=1}^N\sigma (x_n^{\mathrm{\top }}w{)}^{y_n}[1-\sigma (x_n^{\mathrm{\top }}w){]}^{1-y_n}$$

Множник читається просто: якщо $y_n=1$, лишається $\sigma (x_n^{\mathrm{\top }}w)$, якщо $y_n=0$ — лишається $1-\sigma (x_n^{\mathrm{\top }}w)$. Тобто добуток збирає ймовірності, які модель приписала фактично спостереженим міткам.

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

Перехресна ентропія

Логарифм добутку дає суму, а зміна знака робить із неї функцію втрат — перехресну ентропію (cross-entropy, вона ж негативна логарифмічна правдоподібність):

$$\mathcal{L}(w)=-\frac{1}{N}\sum _{n=1}^N[y_n\log \sigma (x_n^{\mathrm{\top }}w)+(1-y_n)\log (1-\sigma (x_n^{\mathrm{\top }}w))]$$

Позначення	Значення
$N$	кількість спостережень у вибірці
$y_n\in \{0,1\}$	справжня мітка $n$-го спостереження
$\sigma (x_n^{\mathrm{\top }}w)\in (0,1)$	ймовірність класу 1, яку дала модель
$-\log (\cdot )$	штраф: прямує до нуля при впевненій правильній відповіді і до нескінченності при впевненій помилковій

Це та сама логістична втрата з розділу про функції втрат: при $y_n=1$ доданок дорівнює $-\log \sigma (g)=\log (1+e^{-g})$, при $y_n=0$ — $-\log (1-\sigma (g))=\log (1+e^g)$, і в позначеннях $y\in \{-1,+1\}$ обидва випадки дають $\log (1+e^{-m})$.

На кожному спостереженні працює рівно один доданок — той, що відповідає справжній мітці. Модель, яка сказала «ймовірність злоякісності 0,99» для злоякісної пухлини, отримує штраф $-\log 0,99\approx 0,01$; та, що сказала 0,01, отримує $-\log 0,01\approx 4,6$.

Матеріали до розділу

• 📄Distill · Visual Information Theoryстаття

  Візуальне пояснення ентропії, перехресної ентропії та розходження Кульбака—Лейблера.

Числовий приклад: перехресна ентропія на п'яти пухлинах

Візьмімо п'ять спостережень з умовними прогнозами — числа підібрано для прикладу, а не взято з моделі — і подивимось, як рахується втрата. Справжні мітки: 1, 1, 0, 0, 0 (одиниця — злоякісна).

Пухлина	Мітка $y_n$	Прогноз $p_n$	Внесок у втрату
1	1	0,97	$-\log 0,97=\mathrm{0,030}$
2	1	0,82	$-\log 0,82=\mathrm{0,198}$
3	0	0,38	$-\log 0,62=\mathrm{0,478}$
4	0	0,08	$-\log 0,92=\mathrm{0,083}$
5	0	0,01	$-\log 0,99=\mathrm{0,010}$

Середнє значення:

$$\mathcal{L}=\frac{\mathrm{0,030}+\mathrm{0,198}+\mathrm{0,478}+\mathrm{0,083}+\mathrm{0,010}}{5}=\mathrm{0,160}$$

Для орієнтиру: модель, яка нічого не вивчила і всім ставить 0,5, дає втрату $\log 2\approx \mathrm{0,693}$. Наша втрата вчетверо менша, отже модель справді щось знає про дані.

Градієнт має той самий вигляд, що в методі найменших квадратів

Щоб мінімізувати перехресну ентропію, потрібна її похідна за вагами. Викладка коротка, бо в сигмоїди зручна похідна. Із $\sigma (z)=(1+e^{-z}{)}^{-1}$ маємо

$${\sigma }^{\prime }(z)=\frac{e^{-z}}{(1+e^{-z}{)}^2}=\sigma (z)(1-\sigma (z)),$$

наприклад, при $z=2$: $\mathrm{0,881}\cdot \mathrm{0,119}=\mathrm{0,105}$. Візьмімо один доданок втрати $\ell =-[y\log \sigma (z)+(1-y)\log (1-\sigma (z))]$ при $z=x^{\mathrm{\top }}w$. Його похідна за $z$:

$$\frac{\partial \ell }{\partial z}=-[y\frac{{\sigma }^{\prime }}{\sigma }-(1-y)\frac{{\sigma }^{\prime }}{1-\sigma }]=-[y(1-\sigma )-(1-y)\sigma ]=\sigma (z)-y.$$

Множник $\sigma (1-\sigma )$ скорочує обидва знаменники — і саме тут з'являється «прогноз мінус мітка». За правилом ланцюга $\partial z/\partial w=x$, тож ${\mathrm{\nabla }}_w\ell =(\sigma (x^{\mathrm{\top }}w)-y)x$. Усереднивши по вибірці, отримуємо напрочуд знайомий результат:

$$\mathrm{\nabla }\mathcal{L}(w)=\frac{1}{N}\sum _{n=1}^N(\sigma (x_n^{\mathrm{\top }}w)-y_n)x_n=\frac{1}{N}{X}^{\mathrm{\top }}(\sigma (Xw)-y)$$

Порівняйте з градієнтом методу найменших квадратів із лекції 02: $\frac{1}{N}{X}^{\mathrm{\top }}(Xw-y)$. Різниця рівно одна — прогноз пропущено через сигмоїду. Структура «(прогноз мінус мітка), зважена на ознаки» зберігається, і вона ж повториться в нейронних мережах у лекції 10.

Перевіримо формулу числом на пацієнтці з попереднього розділу: порахуємо $(\sigma -y)x$ і порівняємо з чисельною похідною — різницею втрат при малому зсуві кожної ваги.

# продовження: спирається на попередні блоки лекції
xb, wb = np.r_[x, 1.0], np.r_[w, w0]  # одиниця в ознаках — під зсув w0
yb = y_te[127]  # справжня мітка пацієнтки: 1 — злоякісна
s = 1 / (1 + np.exp(-xb @ wb))
analytic = (s - yb) * xb  # «прогноз мінус мітка», помножене на ознаки
h = 1e-6  # чисельно: зсуваємо кожну вагу на ±h і дивимося, як змінилася втрата
V = wb + h * np.vstack([np.eye(3), -np.eye(3)])
P = 1 / (1 + np.exp(-V @ xb))
L = -(yb * np.log(P) + (1 - yb) * np.log(1 - P))  # втрата для кожного зсуву
numeric = (L[:3] - L[3:]) / (2 * h)
print(f"σ(z) = {s:.4f}, σ′(z) = σ(1 − σ) = {s * (1 - s):.4f}")
print("аналітичний (σ − y)·x:", np.round(analytic, 4))
print("чисельний:            ", np.round(numeric, 4))

Вивід код запущено, вивід не редагувався

σ(z) = 0.9396, σ′(z) = σ(1 − σ) = 0.0568
аналітичний (σ − y)·x: [ 0.019  -0.0673 -0.0604]
чисельний:             [ 0.019  -0.0673 -0.0604]

На що дивитися: аналітичний градієнт (σ − y)·x і чисельна похідна збігаються до четвертого знака; σ′ у цій точці лише 0,0568, бо пацієнтка далеко від межі, а найбільша похідна сигмоїди, 0,25, — у нулі.

Є й важлива відмінність: рівняння $\mathrm{\nabla }\mathcal{L}(w)=0$ не має розв'язку в замкненій формі. Аналогу нормального рівняння тут немає, тому ваги шукають чисельно.

Функція втрат опукла, тому градієнтний спуск працює

Перехресна ентропія логістичної регресії — опукла функція ваг: її поверхня має форму чаші без западин збоку. Тому в неї немає поганих локальних мінімумів — кожен локальний мінімум є глобальним.

Практичний наслідок важливий: градієнтний спуск не застрягає в поганій точці, і «невдалих ініціалізацій», з якими ми зіткнемось у нейронних мережах, тут немає.

Дві обережності. Опуклість не гарантує, що мінімум досягається в одній-єдиній точці. І сам мінімум може взагалі не досягатися за скінченних ваг — саме цей випадок розбирає розділ «Лінійно роздільні дані ламають оптимізацію».

На рисунку — справжня поверхня втрат моделі на двох стандартизованих ознаках, радіусі й увігнутих точках, без зсуву. Кожен крок градієнтного спуску зсуває ваги проти градієнта: $w\leftarrow w-\eta \mathrm{\nabla }\mathcal{L}(w)$, де $\eta$ — крок навчання. На старті (■) $w=(-2,6;2,9)$, втрата 0,794 і градієнт $(-\mathrm{0,391};-\mathrm{0,253})$, тож перший крок із $\eta =1,6$ веде в $(-\mathrm{1,974};\mathrm{3,304})$, і втрата падає до 0,521. Шістдесят таких кроків приводять у точку ★ із втратою 0,196, майже на дно чаші, — на рисунку це крива від 0,79 до 0,196. Повна модель на тридцяти ознаках — у коді нижче, а віджет під рисунком повторює ці кроки й дає змінити $\eta$.

Ліворуч — лінії рівня втрат і шлях спуску, праворуч — та сама втрата по ітераціях.

Градієнтний спуск на справжній поверхні втрат

Модель на двох стандартизованих ознаках (середнє 0, відхилення 1) — радіусі й увігнутих точках, без зсуву. Кожен крок: w ← w − η·∇𝓛(w). Старт і крок η = 1,6 — ті самі, що на рисунку.

крок навчання η:

лінії рівня втрат і шлях спуску

втрата за кроками

0крок

(−2,600; 2,900)ваги w

0,794втрата 𝓛(w)

(−0,391; −0,253)градієнт ∇𝓛(w)

Натисніть «крок» один раз: із (−2,6; 2,9) і градієнта (−0,391; −0,253) спуск переходить у (−1,974; 3,304), а втрата падає з 0,794 до 0,521 — ті самі числа, що в тексті. «До 60-го кроку» дає 0,196, як на рисунку. Тепер поставте η = 0,3: спуск іде тим самим напрямом, але вп'ятеро повільніше, і за 60 кроків втрата лише 0,252. При η = 5 уже за 60 кроків маємо 0,192 — нижче, ніж при 1,6: ця поверхня полога, і великий крок їй не шкодить. Так буває не завжди: на крутішій поверхні завеликий крок перескакує мінімум, і втрата починає рости, — у лекції 10 це видно на нейронній мережі.

Два способи дійти до мінімуму

Метод	Що робить один крок	Вартість кроку	Поведінка
Градієнтний спуск	$w\leftarrow w-\eta \frac{1}{N}\sum _n\mathrm{\nabla }{\ell }_n(w)$ — градієнт по всій вибірці	$O(ND)$	стабільний, але повільний на великих даних
Стохастичний градієнтний спуск	$w\leftarrow w-\eta \mathrm{\nabla }{\ell }_n(w)$ для випадкового $n$	$O(D)$	крок дешевий, траєкторія шумна

Тут ${\ell }_n$ — втрата на $n$-му спостереженні, $N$ — кількість спостережень, $D$ — кількість ознак. Наприклад, при $w=1$, $\eta =0,1$ і $\mathrm{\nabla }{\ell }_n(w)=2$ крок дає $w=0,8$. Градієнт одного випадково вибраного спостереження в середньому дорівнює повному, тому стохастичний спуск рухається в правильний бік, хоч і з шумом. Для задачі з 569 спостережень і 30 ознак підійде будь-який. Різниця стає вирішальною на мільйонах спостережень, де повний градієнт надто дорогий; тоді залишається стохастичний спуск, до якого ми повернемось у лекції 10.

Код: логістична регресія з нуля

Кілька десятків рядків numpy, щоб було видно, що всередині немає магії — лише формули з попередніх розділів.

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
X = StandardScaler().fit_transform(data.data)  # 569 × 30
y = (data.target == 0).astype(int)  # 1 = злоякісна
X = np.c_[X, np.ones(len(X))]  # стовпець для w0


def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


def loss(w):  # перехресна ентропія
    z = X @ w
    return np.mean(np.logaddexp(0, z) - y * z)  # стійка до переповнення


def gradient(w):  # (1/N) Xᵀ (σ(Xw) − y)
    return X.T @ (sigmoid(X @ w) - y) / len(y)


w = np.zeros(X.shape[1])
for step in range(301):
    if step % 100 == 0:
        print(f"крок {step:3d}   втрата {loss(w):.4f}")
    w -= 0.5 * gradient(w)  # η = 0.5

for _ in range(29_699):  # ще 29 699 кроків: разом із 301 — рівно 30 000
    w -= 0.5 * gradient(w)
errors = int(((X @ w > 0) != y).sum())
print(f"крок 30000 втрата {loss(w):.4f}, помилок на навчанні {errors}", end="")
print(f", ‖w‖ = {np.linalg.norm(w[:-1]):.1f}")

Вивід код запущено, вивід не редагувався

крок   0   втрата 0.6931
крок 100   втрата 0.0685
крок 200   втрата 0.0605
крок 300   втрата 0.0568
крок 30000 втрата 0.0325, помилок на навчанні 7, ‖w‖ = 16.2

На що дивитися: втрата стартує з 0,6931 = ln 2, коли всім приписано ймовірність 0,5, і за 300 кроків падає до 0,0568, але спуск на цьому не зійшовся — див. останній рядок.

Спуск із кроком 0,5 за 300 кроків не зійшовся: навіть після 30 000 кроків втрата лише 0,0325, на навчанні лишається 7 помилок, а довжина вектора ваг ‖w‖ — усього 16,2. Це повільна збіжність, а не розбігання ваг. Розбігання — окрема тема розділу «Лінійно роздільні дані ламають оптимізацію»: воно проявляється лише за дуже довгого навчання без штрафу, і на наших даних ми його побачимо в розділі про регуляризацію.

Код: те саме через scikit-learn

У робочому коді ніхто не пише градієнтний спуск руками. Бібліотечна реалізація додає регуляризацію, кращий оптимізатор і перевірки коректності.

from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
y = (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
    data.data, y, test_size=0.3, stratify=y, random_state=0
)

model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=5000))
model.fit(X_train, y_train)

proba = model.predict_proba(X_test)[:, 1]  # ймовірність злоякісності
print(
    classification_report(
        y_test, proba >= 0.5, target_names=["доброякісна", "злоякісна"]
    )
)
print("ROC-AUC:", round(roc_auc_score(y_test, proba), 3))
unsure = int(((proba > 0.1) & (proba < 0.9)).sum())
print(f"прогнозів між 0,1 і 0,9: {unsure} із {len(proba)}")

Вивід код запущено, вивід не редагувався

              precision    recall  f1-score   support

 доброякісна       0.96      0.96      0.96       107
   злоякісна       0.94      0.94      0.94        64

    accuracy                           0.95       171
   macro avg       0.95      0.95      0.95       171
weighted avg       0.95      0.95      0.95       171

ROC-AUC: 0.992
прогнозів між 0,1 і 0,9: 21 із 171

На що дивитися: рядок accuracy — частка правильних відповідей на 171 відкладеній пацієнтці, 0,95; стовпці precision, recall, f1-score і рядок ROC-AUC розберемо в розділах про оцінювання нижче.

make_pipeline тут не косметика: стандартизація має навчатися тільки на тренувальній частині, інакше інформація про тест просочиться в модель.

Джерело: scikit-learn · LogisticRegression

Масштабування ознак впливає на результат

Середній радіус лежить у межах від 7 до 28, а середня площа — від 144 до 2501. Масштаб діє двома різними шляхами, і їх варто розрізняти.

У методах, що спираються на відстані (сусіди з лекції 06, кластеризація з лекції 08), масштаб змінює саму геометрію: ознака з великим розмахом визначає, хто вважається близьким.

У лінійній моделі без регуляризації розтягнення ознаки компенсується стисненням її ваги, тож межа не змінюється — псується лише обумовленість. Але з регуляризацією (у scikit-learn вона ввімкнена за замовчуванням) масштаб визначає силу штрафу на ознаку — і межа зсувається.

Стандартизація переводить кожну ознаку в $x^{\prime }=(x-\mu )/s$, де $\mu$ і $s$ — середнє та стандартне відхилення ознаки на навчальній частині; наприклад, при $\mu =10$ і $s=2$ значення 13 стає 1,5.

На рисунку — перший шлях: метод k найближчих сусідів на наборі Wine, ліворуч навчений на сирих ознаках, праворуч — на стандартизованих. Той самий алгоритм, ті самі дані, інша межа. Другий шлях — через регуляризацію — рисунок не показує.

Англійські підписи: KNN without / with scaling — метод сусідів без стандартизації і з нею; осі — ознаки proline і hue набору Wine (scaled — стандартизовані).

Джерело: scikit-learn · Importance of Feature Scaling

Лінійно роздільні дані ламають оптимізацію

Якщо класи можна розділити прямою без жодної помилки, у перехресної ентропії з'являється неприємна властивість: її нижня межа нуль не досягається на жодному скінченному $w$.

Причина в тому, що модель завжди може стати ще впевненішою. Помножимо всі ваги на 10 — межа рішення залишиться тією самою, але сигмоїда стане крутішою, ймовірності наблизяться до 0 і 1, а втрата зменшиться. Оптимізатор буде нескінченно збільшувати $\parallel w\parallel$, женучи сигмоїду до сходинки.

Наслідки практичні: ваги розбігаються до величезних значень, модель стає гранично самовпевненою і будь-яке нове спостереження біля межі отримує ймовірність 0 або 1 без жодних підстав. Чи роздільні наші тридцять ознак, перевіримо в наступному розділі.

Регуляризація зупиняє розбігання ваг

Ліки прямі: додати до функції втрат штраф за довжину вектора ваг.

$${\mathcal{L}}_{\text{reg}}(w)=-\frac{1}{N}\sum _{n=1}^N[y_n\log {\sigma }_n+(1-y_n)\log (1-{\sigma }_n)]+\frac{\lambda }{2}\parallel w{\parallel }_2^2$$

Тут ${\sigma }_n=\sigma (x_n^{\mathrm{\top }}w)$ — ймовірність класу 1 для $n$-го спостереження. Тепер зростання $\parallel w\parallel$ коштує грошей, і мінімум досягається на скінченних вагах. Параметр $\lambda$ керує компромісом: великий $\lambda$ тримає ваги малими й робить модель обережнішою, малий — дає їй свободу.

У scikit-learn задають не $\lambda$, а обернену до неї величину C: у формулі вище $\lambda =1/(CN)$, тож менше C означає сильнішу регуляризацію.

Перевіримо це на наших тридцяти стандартизованих ознаках: навчимо ту саму модель із дедалі слабшим штрафом.

# продовження: спирається на попередні блоки лекції
Xs = X[:, :-1]  # 30 стандартизованих ознак із блока «з нуля», без стовпця одиниць
for C in (1.0, 1e4, 1e8):  # що більше C, то слабший штраф
    m = LogisticRegression(C=C, max_iter=100_000).fit(Xs, y)
    errors = int((m.predict(Xs) != y).sum())
    norm = np.linalg.norm(m.coef_)
    print(f"C = {C:<6g} помилок на навчанні {errors:2d}   ‖w‖ = {norm:7.1f}")

Вивід код запущено, вивід не редагувався

C = 1      помилок на навчанні  7   ‖w‖ =     3.8
C = 10000  помилок на навчанні  4   ‖w‖ =   137.3
C = 1e+08  помилок на навчанні  0   ‖w‖ =  7726.8

На що дивитися: що слабший штраф, то менше помилок на навчанні і то довший вектор ваг: майже без штрафу (C = 10⁸) модель розділяє всі 569 пухлин без жодної помилки, а ‖w‖ сягає 7726,8 — наші дані лінійно роздільні, і ваги розбігаються.

На рисунку — коефіцієнти логістичної регресії, що відрізняє цифри 0–4 від 5–9 на зображеннях 8×8 з набору Digits: кожен квадрат — 64 ваги, по одній на піксель. Видно, як зменшення C обнуляє дедалі більше коефіцієнтів при штрафі ${\ell }_1$ і просто стискає їх при ${\ell }_2$.

Англійські підписи: L1 / L2 penalty — штраф ℓ₁ / ℓ₂, Elastic-Net, l1_ratio = 0.5 — їхня суміш навпіл; темніший піксель — більша за модулем вага, білий — нульова.

Джерело: scikit-learn · L1 Penalty and Sparsity in Logistic Regression

Частка правильних відповідей — оманлива метрика

Модель навчено. Тепер треба виміряти, наскільки вона добра, і тут перша ж очевидна метрика підводить.

Уявімо скринінг, де злоякісних пухлин 1 %. Модель, яка завжди відповідає «доброякісна», має частку правильних відповідей (accuracy) 99 % і при цьому абсолютно даремна: вона не знайшла жодного хворого. Чим сильніший дисбаланс класів, тим менше значить ця метрика.

Тому оцінювання починають не з одного числа, а з таблиці, яка розкладає відповіді моделі за типами помилок.

Порахуймо той самий скринінг на 1000 пацієнтках, серед яких 10 злоякісних пухлин. Числа в таблиці умовні: третя модель — гіпотетична, щоб показати механіку метрики.

Модель	Знайдено злоякісних	Хибних тривог	Частка правильних	Придатність
«завжди доброякісна»	0 з 10	0	99,0 %	нульова
«завжди злоякісна»	10 з 10	990	1,0 %	нульова
добра модель (умовна)	9 з 10	12	98,7 %	висока

Найвищу частку правильних відповідей має модель, яка не знайшла жодної хворої, а найкорисніша з трьох виглядає за цією метрикою гірше за неї.

Матеріали до розділу

• ⚙scikit-learn · Metrics and scoringдокументація

  Формули всіх метрик класифікації в одному місці.

• 🎓Google · Classification: Accuracy, Precision, Recallкурс

  Той самий приклад із рідкісним класом, розібраний покроково.

Матриця похибок розкладає відповіді за типами

Матриця похибок (confusion matrix) зіставляє справжній клас із передбаченим. Для бінарної задачі в ній чотири клітинки:

• TP — злоякісну пухлину визначено як злоякісну;
• TN — доброякісну визначено як доброякісну;
• FP — хибна тривога: доброякісну названо злоякісною;
• FN — пропуск: злоякісну названо доброякісною.

Ці дві помилки нерівноцінні. Хибна тривога означає зайве обстеження, пропуск — невиявлений рак. Звичайні метрики, що зводять матрицю до одного числа, цієї різниці не бачать, поки ми самі не задамо ціну кожної помилки, — тому дивитись треба саме на матрицю.

На рисунку — матриця нашої моделі на 171 тестовій пацієнтці при порозі 0,5. Частка правильних відповідей — це діагональ, поділена на все: $(TP+TN)/N=(60+103)/171=0,95$.

Рядки — справжній клас, стовпці — передбачений; на діагоналі правильні відповіді, поза нею — два типи помилок.

Точність і повнота відповідають на різні питання

З чотирьох клітинок матриці будують дві метрики.

$$\text{Precision}=\frac{TP}{TP+FP},\text{Recall}=\frac{TP}{TP+FN}$$

Точність (precision): серед тих, кого модель назвала злоякісними, скільки справді злоякісні — це надійність тривоги. Повнота (recall, або чутливість): серед усіх справді злоякісних, скільки модель знайшла — це охоплення. На матриці точність читають у стовпці «передбачено злоякісна», повноту — у рядку «справді злоякісна»: чисельник спільний, 60 TP, а знаменники різні.

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

Зазвичай між ними компроміс: оголосивши всіх злоякісними, отримаємо повноту 100 %, а точність упаде до частки злоякісних, $64/171=0,37$. F1-міра — їхнє гармонічне середнє $2PR/(P+R)$ — зводить обидві в одне число, але приховує, якою ціною воно досягнуте. У нас обидві дорівнюють $60/64=0,94$, тож $F1=0,94$ — ті самі числа, що в рядку «злоякісна» звіту класифікації.

Поріг рухає матрицю похибок

Модель видає ймовірність, а клас вирішує поріг. Та сама модель на 171 пацієнтці при трьох порогах:

# продовження: спирається на попередні блоки лекції
from sklearn.metrics import confusion_matrix

print("поріг   TN  FP  FN  TP  точність  повнота")
for t in (0.1, 0.5, 0.9):
    tn, fp, fn, tp = confusion_matrix(y_test, proba >= t).ravel()
    prec, rec = tp / (tp + fp), tp / (tp + fn)
    print(f"{t:5.1f} {tn:4d} {fp:3d} {fn:3d} {tp:3d} {prec:9.3f} {rec:8.3f}")

Вивід код запущено, вивід не редагувався

поріг   TN  FP  FN  TP  точність  повнота
  0.1   93  14   1  63     0.818    0.984
  0.5  103   4   4  60     0.938    0.938
  0.9  107   0   8  56     1.000    0.875

На що дивитися: знизивши поріг з 0,5 до 0,1, ми пропускаємо одну пухлину замість чотирьох, але хибних тривог стає 14 замість чотирьох; при 0,9 хибних тривог немає зовсім, зате пропусків вісім.

Чи вигідний обмін, вирішує клініка: якщо пропуск, скажімо, удесятеро дорожчий за зайве обстеження, 10 додаткових тривог за 3 знайдені пухлини окупаються, $10\cdot 1<3\cdot 10$.

Червона крива — пропущені злоякісні пухлини, синя — хибні тривоги на тих самих 171 пацієнтці; пунктир — поріг 0,5.

ROC-крива показує модель на всіх порогах одразу

ROC-крива (receiver operating characteristic) збирає такі матриці для всіх порогів, по точці на поріг. По горизонталі — $\text{FPR}=FP/(FP+TN)$, частка хибних тривог серед доброякісних, по вертикалі — $\text{TPR}=TP/(TP+FN)$, тобто повнота. При порозі 0,5 маємо $\text{FPR}=4/107=\mathrm{0,037}$ і $\text{TPR}=60/64=\mathrm{0,938}$. Поріг, вищий за всі оцінки, дає точку (0; 0), нижчий за всі — (1; 1).

Ідеальна модель проходить через лівий верхній кут, діагональ — випадкове вгадування.

Кожна точка кривої — один поріг; кольорові точки — пороги 0,1, 0,5 і 0,9 з попереднього розділу.

AUC — частка правильно впорядкованих пар

Площу під ROC-кривою, AUC, читають так: візьмемо випадкову злоякісну й випадкову доброякісну пацієнтку — як часто модель дасть злоякісній вищу оцінку? Шість пацієнток для прикладу (оцінки умовні):

Пацієнтка	Оцінка	Клас	Доброякісні з нижчою оцінкою
А	0,95	злоякісна	В, Д, Е — 3 з 3
Б	0,80	злоякісна	В, Д, Е — 3 з 3
В	0,60	доброякісна	—
Г	0,40	злоякісна	Д, Е — 2 з 3; пару з В переплутано
Д	0,20	доброякісна	—
Е	0,05	доброякісна	—

Пар «злоякісна — доброякісна» тут $3\times 3=9$, правильно впорядкованих $3+3+2=8$, тож $\text{AUC}=8/9=\mathrm{0,889}$; пара з однаковими оцінками йде за половину. Код робить те саме на всіх тестових пацієнтках:

# продовження: спирається на попередні блоки лекції
pos, neg = proba[y_test == 1], proba[y_test == 0]  # злоякісні й доброякісні
higher = (pos[:, None] > neg[None, :]).mean()  # злоякісна вище за доброякісну
ties = (pos[:, None] == neg[None, :]).mean()  # однакові оцінки — за половину
print(f"пар «злоякісна — доброякісна»: {len(pos)} × {len(neg)} = {len(pos) * len(neg)}")
print(f"частка правильно впорядкованих: {higher + 0.5 * ties:.4f}")
print(f"roc_auc_score:                  {roc_auc_score(y_test, proba):.4f}")

Вивід код запущено, вивід не редагувався

пар «злоякісна — доброякісна»: 64 × 107 = 6848
частка правильно впорядкованих: 0.9917
roc_auc_score:                  0.9917

На що дивитися: перебір 6848 пар і бібліотечна функція дають те саме число, 0,9917, — це одна величина, порахована двома способами.

Отже, AUC залежить лише від порядку оцінок: піднесіть усі до квадрата — AUC не зміниться. Чи правдиві самі ймовірності, він не бачить; це перевіряє калібрування.

Крива точність–повнота чесніша при дисбалансі

Крива точність–повнота (precision-recall curve) будується так само, лише в інших осях: кожен поріг дає точку (повнота; точність). При порозі 0,9 це $(\mathrm{0,875};\mathrm{1,000})$, при 0,1 — $(\mathrm{0,984};\mathrm{0,818})$. Базовий рівень — не діагональ, а горизонталь на висоті частки позитивного класу: модель, що тривожить навмання, у середньому має точність $64/171=0,37$. Криву підсумовує середня точність (average precision, AP) — сума точностей $P_i$, зважених приростами повноти:

$$\text{AP}=\sum _i(R_i-R_{i-1})P_i$$

Наприклад, якщо дві злоякісні пухлини стоять у рейтингу на першому й третьому місцях, то $\text{AP}=\frac{1}{2}\cdot 1+\frac{1}{2}\cdot \frac{2}{3}=\mathrm{0,833}$. У нас AP = 0,989.

Ті самі пороги 0,1, 0,5 і 0,9, що на ROC-кривій; пунктир — базовий рівень 0,37.

Поріг вирішує, яким буде діагноз

Справжні передбачення моделі з коду scikit-learn: логістична регресія на Breast Cancer Wisconsin, відкладені 171 спостереження. Модель не змінюється — змінюється лише поріг, і разом із ним матриця похибок, точка на ROC-кривій і точка на кривій точність–повнота.

Поріг = 0,500

Ціна пропущеної пухлини = 10Ціна хибної тривоги = 1

Матриця похибок

	прогноз: доброякісна	прогноз: злоякісна
факт: доброякісна	103правильно	4хибна тривога
факт: злоякісна	4пропущено	60виявлено

ROC-крива: AUC = 0,992

Точність–повнота: AP = 0,989

0,938повнота: скільки злоякісних знайдено

0,938точність: скільки тривог справдилися

0,938F1 — гармонічне середнє точності й повноти

4пропущено злоякісних пухлин

44сумарна ціна помилок; мінімум на цих 171 пацієнтках — 24

Зсуньте поріг до 0,1 — пропусків стане один замість чотирьох, а хибних тривог чотирнадцять замість чотирьох. Це той самий обмін, що в розділі «Поріг рухає матрицю похибок». Точка на ROC-кривій при цьому повзе вправо й угору, а на кривій точність–повнота — вправо й униз: повнота росте, точність падає. Жодна метрика не скаже, який поріг правильний: це вирішує ціна помилки в клініці, а не модель. AUC і AP при цьому не змінюються взагалі — криві описують модель на всіх порогах одразу, тому вибір порога вони не підказують. Поріг 0,43 для максимуму F1 пораховано нижче, у розділі «Поріг можна підбирати автоматично», а формулу порога за Баєсом виведено в розділі «Поріг за ціною помилок».

Тепер задайте ціну помилок числами — і поріг перестане бути справою смаку. Якщо пропустити злоякісну пухлину вдесятеро дорожче за хибну тривогу, теорія дає поріг C_FP / (C_FP + C_FN), тобто 0,091: саме там очікувані втрати від двох рішень зрівнюються. Друга кнопка ставить поріг, найкращий на цих конкретних 171 спостереженні, — тут це 0,030. Це підбір на тестовій вибірці: так робити не можна, кнопка лише показує, наскільки оптимістичною виходить така оцінка. Сумарні втрати виходять однакові, 24, хоча матриці похибок різні: один пропуск і чотирнадцять тривог проти жодного пропуску і двадцяти чотирьох. Баєсів поріг оптимальний для справжніх імовірностей, емпіричний підлаштовується під випадковість маленької вибірки: його оцінка оптимістична, і перевага на нових даних не гарантована. І головне: зрівняйте обидві ціни. Баєсів поріг стане рівно 0,5 — тим самим, який бібліотека ставить за замовчуванням. Отже, 0,5 — не константа, а мовчазне припущення, що обидві помилки коштують однаково.

Матеріали до розділу

• ⚙scikit-learn · Precision-Recallдокументація

  Готовий приклад побудови обох кривих на одному наборі.

На рідкісному класі ROC-крива оманлива

Візьмімо набір операцій за банківськими картками, де шахрайських лише 0,17 % (докладно — у розділі «Дисбаланс класів: у чому проблема»). Логістична регресія на ньому має ROC-AUC 0,976 — майже як на пухлинах, 0,992. Крива точність–повнота показує правду: AP лише 0,728 проти 0,989.

Причина в знаменниках. FPR ділить хибні тривоги на всі звичайні операції тесту, а їх 85 295: навіть 1000 хибних тривог (умовний приклад) — це лише $\text{FPR}=1000/85295=\mathrm{0,012}$, на ROC-кривій майже нуль. Точність ділить на кількість тривог: якщо серед 1130 тривог справжніх шахрайських операцій 130, точність лише $130/1130=\mathrm{0,115}$.

Синім — пухлини, червоним — шахрайство (у тесті 148 шахрайських і 85 295 звичайних операцій); точкові лінії праворуч — базові рівні кривих точність–повнота, 0,37 і 0,0017.

Правило: класи збалансовані й помилки однаково важливі — ROC; цікавить рідкісний клас — крива точність–повнота.

Матеріали до розділу

• 📄Saito T., Rehmsmeier M. The Precision-Recall Plot Is More Informative than the ROC Plotстаття

  Стаття в PLOS ONE, де показано на симуляціях, коли саме ROC вводить в оману.

Поріг можна підбирати автоматично

Поріг — гіперпараметр, і підбирають його так само, як інші: без тестової вибірки. TunedThresholdClassifierCV робить це за п'ять кроків:

Крок	Що відбувається
1	ділить навчальну частину на 5 фолдів
2	для кожного фолду навчає модель на решті чотирьох і рахує ймовірності для нього
3	на кожному фолді рахує F1 для сітки порогів
4	усереднює F1 по фолдах і бере поріг із найбільшим середнім
5	навчає модель на всій навчальній частині й ставить цей поріг

# продовження: спирається на попередні блоки лекції
from sklearn.base import clone
from sklearn.metrics import f1_score
from sklearn.model_selection import StratifiedKFold, TunedThresholdClassifierCV

grid = np.arange(1, 100) / 100  # пороги 0,01 … 0,99 — спільні для всіх фолдів
tuned = TunedThresholdClassifierCV(
    model, scoring="f1", cv=5, thresholds=grid, store_cv_results=True
)
tuned.fit(X_train, y_train)
for k, (tr, va) in enumerate(StratifiedKFold(5).split(X_train, y_train), 1):
    p_va = clone(model).fit(X_train[tr], y_train[tr]).predict_proba(X_train[va])[:, 1]
    best_k = grid[np.argmax([f1_score(y_train[va], p_va >= t) for t in grid])]
    print(f"фолд {k}: найкращий поріг {best_k:.2f}")
print("за середнім F1 по фолдах:", round(tuned.best_threshold_, 2))

Вивід код запущено, вивід не редагувався

фолд 1: найкращий поріг 0.28
фолд 2: найкращий поріг 0.52
фолд 3: найкращий поріг 0.37
фолд 4: найкращий поріг 0.34
фолд 5: найкращий поріг 0.43
за середнім F1 по фолдах: 0.43

На що дивитися: найкращі пороги окремих фолдів розкидані від 0,28 до 0,52; середній F1 однаковий на плато від 0,43 до 0,49, і бібліотека бере його перший поріг, 0,43.

Сірі криві — F1 на кожному з п'яти фолдів, синя — їхнє середнє; червона лінія — обраний поріг 0,43.

Замість F1 можна задати ціну помилок — її розберемо в розділі «Поріг за ціною помилок».

Джерело: scikit-learn · Post-hoc tuning the cut-off point

Дисбаланс класів: у чому проблема

Дисбаланс класів (class imbalance) — ситуація, коли один клас набагато рідший за інший. Розберемо її на наборі Credit Card Fraud Detection (ULB, Kaggle): 284 807 операцій за картками європейських власників за два дні вересня 2013 року. Ознаки — 28 знеособлених компонент V1–V28 (автори набору, Worldline і ULB, перетворили справжні ознаки методом головних компонент, лекція 09) і сума операції Amount; ціль — чи була операція шахрайською. У версії OpenML 1597, яку ми завантажуємо, ознаки часу Time немає.

Біда не лише в метриці. Модель «усі звичайні» вгадує 99,83 % відповідей і не знаходить жодної шахрайської операції, але страждає й навчання: втрата — середнє по всіх прикладах, і 99,8 % її доданків дають звичайні операції. Мінімізуючи її, модель передусім вчиться не помилятися на них, а шахрайству приписує малі ймовірності.

# продовження: спирається на попередні блоки лекції
from sklearn.datasets import fetch_openml

fr = fetch_openml(data_id=1597, as_frame=True, parser="auto").frame
y_fr = (fr["Class"].astype(int) == 1).to_numpy()  # True — шахрайство
X_fr = fr.drop(columns=["Class"]).to_numpy(float)  # V1–V28 і сума Amount
fr_tr, fr_te, yfr_tr, yfr_te = train_test_split(
    X_fr, y_fr, test_size=0.3, stratify=y_fr, random_state=0
)
n_k = np.bincount(yfr_tr)  # звичайних і шахрайських у навчальній частині
print(f"навчальна частина: {n_k[0]} і {n_k[1]}, тобто 1 : {n_k[0] / n_k[1]:.0f}")
print(f"«усі звичайні» на тесті: частка правильних {(~yfr_te).mean():.4f}")


def logreg(**kw):
    return make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000, **kw))


def summary(p, t=0.5):  # повнота, точність і хибні тривоги на тесті при порозі t
    tn, fp, fn, tp = confusion_matrix(yfr_te, p >= t).ravel()
    return f"повнота {tp / (tp + fn):.3f}, точність {tp / (tp + fp):.3f}, хибних {fp}"


p_base = logreg().fit(fr_tr, yfr_tr).predict_proba(fr_te)[:, 1]
tn, fp, fn, tp = confusion_matrix(yfr_te, p_base >= 0.5).ravel()
print(f"поріг 0,5: знайдено {tp} шахрайських із {tp + fn}, хибних тривог {fp}")

Вивід код запущено, вивід не редагувався

навчальна частина: 199020 і 344, тобто 1 : 579
«усі звичайні» на тесті: частка правильних 0.9983
поріг 0,5: знайдено 89 шахрайських із 148, хибних тривог 14

На що дивитися: на одну шахрайську операцію припадає 579 звичайних; при порозі 0,5 модель знаходить 89 шахрайських операцій зі 148, а 59 пропускає.

Розподіл передбаченої ймовірності шахрайства на тесті, кількість — у логарифмічній шкалі: звичайні операції синім, шахрайські червоним. Ліворуч від порога 0,5 лишається 59 шахрайських зі 148.

Боротися з дисбалансом можна на чотирьох рівнях, і кожному далі присвячено окремий розділ:

• оцінювання — метрики, які бачать рідкісний клас;
• рішення — поріг, обчислений із цін помилок;
• функція втрат — ваги класів і фокальна втрата (focal loss);
• дані — передискретизація, зокрема SMOTE, і недодискретизація.

Наприкінці порівняємо всі способи на тих самих даних.

Матеріали до розділу

• 🎓Google · Imbalanced datasetsкурс

  Короткий розбір дисбалансу з прикладами недодискретизації і зважування.

• ⚙imbalanced-learn · User guideдокументація

  Бібліотека з передискретизацією, SMOTE, недодискретизацією і конвеєрами, що роблять їх усередині фолдів.

Метрики для незбалансованих класів

Частка правильних відповідей тут марна: «усі звичайні» отримують 0,9983, наша модель — 0,9991. Потрібні метрики, що дивляться на рідкісний клас. Порахуємо кожну для моделі при порозі 0,5, де $TP=89$, $FP=14$, $FN=59$, $TN=85281$, і для «усі звичайні».

Повнота і точність (розділ 27): у моделі $89/148=\mathrm{0,601}$ і $89/103=\mathrm{0,864}$, у моделі «усі звичайні» повнота 0 — провал видно одразу.

F-міра зводить їх в одне число, а параметр $\beta$ задає, у скільки разів повнота важливіша за точність:

$$F_{\beta }=(1+{\beta }^2)\frac{P\cdot R}{{\beta }^{2}P+R}$$

При $\beta =1$ це F1 = 0,709. При $\beta =2$ повноту вважають удвічі важливішою:

$$F_2=\frac{5\cdot \mathrm{0,864}\cdot \mathrm{0,601}}{4\cdot \mathrm{0,864}+\mathrm{0,601}}=\mathrm{0,640}$$

Це нижче за F1, бо повнота в нас слабша за точність.

Збалансована частка правильних (balanced accuracy) — середнє повнот обох класів, $\frac{1}{2}(\frac{TP}{TP+FN}+\frac{TN}{TN+FP})$: у моделі $\frac{1}{2}(89/148+85281/85295)=\mathrm{0,801}$, у моделі «усі звичайні» — рівно 0,5, як у монетки.

Коефіцієнт кореляції Метьюза (Matthews correlation coefficient, MCC) використовує всі чотири клітинки матриці:

$$\text{MCC}=\frac{TP\cdot TN-FP\cdot FN}{\sqrt{(TP+FP)(TP+FN)(TN+FP)(TN+FN)}}$$

Він змінюється від −1 до 1, а 0 означає рівень випадкового вгадування. У моделі $\frac{89\cdot 85281-14\cdot 59}{\sqrt{103\cdot 148\cdot 85295\cdot 85340}}=\mathrm{0,720}$; у моделі «усі звичайні» знаменник нульовий, і MCC за домовленістю вважають 0.

Середня точність (AP, розділ 31) не залежить від порога: 0,728 проти базового рівня 0,0017.

# продовження: спирається на попередні блоки лекції
from sklearn.metrics import (
    accuracy_score,
    average_precision_score,
    balanced_accuracy_score,
    f1_score,
    fbeta_score,
    matthews_corrcoef,
    precision_score,
    recall_score,
)

never = np.zeros_like(yfr_te)  # «усі звичайні»: жодної тривоги
METRICS = {
    "частка правильних": accuracy_score,
    "збалансована частка": balanced_accuracy_score,
    "точність": lambda y, p: precision_score(y, p, zero_division=0),
    "повнота": recall_score,
    "F1": lambda y, p: f1_score(y, p, zero_division=0),
    "F2": lambda y, p: fbeta_score(y, p, beta=2, zero_division=0),
    "MCC": matthews_corrcoef,
}
print(f"{'метрика':20s} усі звичайні  модель, поріг 0,5")
for name, metric in METRICS.items():
    m0, m1 = metric(yfr_te, never), metric(yfr_te, p_base >= 0.5)
    print(f"{name:20s} {m0:12.4f} {m1:12.4f}")
ap = average_precision_score(yfr_te, p_base)
print(f"AP: базовий рівень {yfr_te.mean():.4f}, модель {ap:.3f}")

Вивід код запущено, вивід не редагувався

метрика              усі звичайні  модель, поріг 0,5
частка правильних          0.9983       0.9991
збалансована частка        0.5000       0.8006
точність                   0.0000       0.8641
повнота                    0.0000       0.6014
F1                         0.0000       0.7092
F2                         0.0000       0.6403
MCC                        0.0000       0.7205
AP: базовий рівень 0.0017, модель 0.728

На що дивитися: частка правильних у двох моделей майже однакова (0,9983 і 0,9991), а решта метрик розводить їх: від 0 (для збалансованої частки — 0,5) до 0,60–0,86.

Яку метрику обрати, вирішує задача: якщо головне — знайти якомога більше шахрайських операцій, беруть F2 або повноту за заданої точності; якщо ціни помилок відомі — сумарний збиток із наступного розділу.

Матеріали до розділу

• ⚙scikit-learn · matthews_corrcoefдокументація

  Формула MCC і приклад обчислення.

Поріг за ціною помилок

Поріг за ціною помилок (cost-sensitive threshold) — поріг, обраний не за звичкою, а з того, скільки коштує кожна помилка. Для банку пропущене шахрайство коштує суму операції — у середньому $C_{FN}=128$ (середня сума шахрайської операції в навчальній частині), а хибна тривога — дзвінок оператора клієнту, умовно $C_{FP}=5$.

Нехай модель каже, що операція шахрайська з імовірністю $p$. Рішень два:

• мовчати — помилимося, якщо це шахрайство; очікувана втрата $p\cdot C_{FN}$;
• підняти тривогу — помилимося, якщо операція звичайна; очікувана втрата $(1-p)\cdot C_{FP}$.

Тут припускаємо, що правильні рішення нічого не коштують, а ціна пропуску однакова для всіх операцій (насправді вона дорівнює сумі конкретної операції). Тривога вигідна, коли вона дешевша за мовчання, $p\cdot C_{FN}>(1-p)\cdot C_{FP}$, тобто коли

$$p>t^{\ast }=\frac{C_{FP}}{C_{FP}+C_{FN}}=\frac{5}{5+128}=\mathrm{0,037}6$$

Приклад: операція з $p=0,1$. Мовчання коштує в середньому $0,1\cdot 128=12,8$, тривога — $0,9\cdot 5=4,5$, тож дзвонимо, хоча з порогом 0,5 модель промовчала б. Якщо ціни рівні, $t^{\ast }=0,5$: стандартний поріг — це мовчазне припущення, що обидві помилки коштують однаково.

Очікувана втрата двох рішень залежно від імовірності шахрайства $p$: мовчання $p\cdot 128$ (червона пряма) і тривога $(1-p)\cdot 5$ (синя); вони перетинаються в $t^{\ast }=\mathrm{0,037}6$, праворуч від нього дешевша тривога. Точки — приклад $p=0,1$.

# продовження: спирається на попередні блоки лекції
C_FN = round(float(fr_tr[yfr_tr, -1].mean()))  # середня сума шахрайства, лише train
C_FP = 5  # дзвінок оператора — умовна ціна
thr_cost = C_FP / (C_FP + C_FN)
print(f"C_FN = {C_FN}, C_FP = {C_FP}, поріг за ціною {thr_cost:.4f}")
p = 0.1  # одна операція для прикладу
print(f"p = {p}: мовчання коштує {p * C_FN:.1f}, тривога {(1 - p) * C_FP:.1f}")
for t in (0.5, thr_cost):
    tn, fp, fn, tp = confusion_matrix(yfr_te, p_base >= t).ravel()
    print(f"поріг {t:.4f}: пропущено {fn}, хибних {fp}, збиток {fn * C_FN + fp * C_FP}")

Вивід код запущено, вивід не редагувався

C_FN = 128, C_FP = 5, поріг за ціною 0.0376
p = 0.1: мовчання коштує 12.8, тривога 4.5
поріг 0.5000: пропущено 59, хибних 14, збиток 7622
поріг 0.0376: пропущено 29, хибних 41, збиток 3917

На що дивитися: той самий класифікатор із порогом 0,0376 пропускає 29 шахрайських операцій замість 59 ціною 41 хибної тривоги замість 14, і збиток падає з 7622 до 3917.

Формула $t^{\ast }$ спирається на те, що ймовірності чесні: модель, яка каже 0,1, має мати рацію приблизно в 10 % таких випадків. Що робити, коли це не так, — у розділах про калібрування.

Зважування класів

Зважування класів (class weighting) змінює не рішення, а навчання: кожен доданок функції втрат множать на вагу $c$ класу цього прикладу,

$$\mathcal{L}(w)=-\frac{1}{N}\sum _{n=1}^N{c}_{y_n}[y_n\log p_n+(1-y_n)\log (1-p_n)]$$

де $c_0$ і $c_1$ — ваги звичайного і шахрайського класу. Помилка на прикладі з більшою вагою коштує дорожче, тож межа рішення відсувається вглиб частого класу.

Ваги задають двома способами.

• class_weight='balanced' бере $c_k=N/(K{n}_k)$, де $N$ — розмір навчальної частини, $K=2$ — кількість класів, $n_k$ — кількість прикладів класу $k$. Тоді $n_k{c}_k=N/K$: обидва класи разом важать однаково. У нас $c_0=\mathrm{0,501}$ і $c_1=289,8$, тож одна шахрайська операція важить як 579 звичайних.
• Ваги за цінами помилок: $c_0=C_{FP}=5$ і $c_1=C_{FN}=128$, тобто class_weight={0: 5, 1: 128}; шахрайство важить як 25,6 звичайних.

Різниця принципова: balanced мовчки припускає, що пропущене шахрайство коштує як 579 хибних тривог, хоча насправді — як $128/5=25,6$. Якщо модель правильно описує ймовірності, ваги за цінами разом із порогом 0,5 дають те саме рішення, що поріг $t^{\ast }$ на незваженій моделі; на практиці результати близькі — порівняння нижче.

Англійські підписи: non weighted / weighted — межа без ваг і з більшою вагою рідкісного класу. Рисунок для методу опорних векторів (лекція 07), але параметр class_weight діє так само: межа відсувається від рідкісного класу (коричневі точки) вглиб частого.

Джерело: scikit-learn · SVM: Separating hyperplane for unbalanced classes

# продовження: спирається на попередні блоки лекції
c_k = len(yfr_tr) / (2 * n_k)  # class_weight='balanced': N / (K · n_k)
print(
    f"balanced: ваги {c_k[0]:.3f} і {c_k[1]:.1f}, співвідношення {c_k[1] / c_k[0]:.0f}"
)
print(f"за цінами: ваги {C_FP} і {C_FN}, співвідношення {C_FN / C_FP:.1f}")
p_bal = logreg(class_weight="balanced").fit(fr_tr, yfr_tr).predict_proba(fr_te)[:, 1]
p_cw = (
    logreg(class_weight={0: C_FP, 1: C_FN})
    .fit(fr_tr, yfr_tr)
    .predict_proba(fr_te)[:, 1]
)
for tag, p in [("balanced", p_bal), ("за цінами", p_cw)]:
    print(f"{tag:9s} {summary(p)}")

Вивід код запущено, вивід не редагувався

balanced: ваги 0.501 і 289.8, співвідношення 579
за цінами: ваги 5 і 128, співвідношення 25.6
balanced  повнота 0.899, точність 0.069, хибних 1804
за цінами повнота 0.824, точність 0.659, хибних 63

На що дивитися: balanced знаходить 133 шахрайські операції зі 148 (повнота 0,899), але піднімає 1804 хибні тривоги; ваги за цінами дають повноту 0,824 при 63 хибних тривогах.

Передискретизація: копії і синтетичні приклади SMOTE

Передискретизація (oversampling) змінює дані: до навчальної частини додають приклади рідкісного класу, доки класів не стане порівну. У нас треба додати $199020-344=198676$ шахрайських операцій. Способів два.

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

Навчальна частина до й після передискретизації: 344 шахрайські операції повторюються, доки їх не стане 199 020.

SMOTE (Synthetic Minority Over-sampling Technique, Chawla et al., 2002) не копіює, а створює нові точки між сусідами. Беруть шахрайську операцію $x_i$, одного з її $k$ найближчих шахрайських сусідів $x_j$ і випадкове число $\lambda$ між 0 і 1:

$$x_{\text{new}}=x_i+\lambda (x_j-x_i)$$

Нова точка лежить на відрізку між $x_i$ і $x_j$. На рисунку нижче $x_i\approx (0,60;3,52)$, сусід $x_j\approx (0,40;3,22)$ і $\lambda =0,5$ дають $x_{\text{new}}\approx (0,50;3,37)$ — середину відрізка.

Англійські підписи: Minority / Majority class — рідкісний і частий клас; x_i — опорна точка, x_zi — обраний сусід (у тексті $x_j$), x_new — нова синтетична точка; блакитна область — коло з центром у x_i, що сягає обраного сусіда.

Джерело: imbalanced-learn · Sample generator used in SMOTE-like samplers

Головне застереження — витік даних (data leakage). Передискретизацію роблять лише на навчальній частині і лише після розбиття, а при перехресній перевірці — окремо в кожному фолді. Якщо спершу розмножити шахрайство, а потім розбити, копії тієї самої операції потраплять і в навчання, і в тест, і метрики стануть оманливо добрими.

# продовження: спирається на попередні блоки лекції
from sklearn.neighbors import NearestNeighbors

idx_pos, idx_neg = np.where(yfr_tr)[0], np.where(~yfr_tr)[0]
n_new = len(idx_neg) - len(idx_pos)  # скільки шахрайських додати до рівності
copies = np.random.default_rng(0).choice(idx_pos, n_new, replace=True)
X_over, y_over = np.r_[fr_tr, fr_tr[copies]], np.r_[yfr_tr, yfr_tr[copies]]
p_over = logreg().fit(X_over, y_over).predict_proba(fr_te)[:, 1]


def smote(X_min, n_new, k=5, seed=0):  # SMOTE з нуля
    rng = np.random.default_rng(seed)
    Z = X_min / X_min.std(axis=0)  # сусідів шукаємо в стандартизованих ознаках
    nbrs = (
        NearestNeighbors(n_neighbors=k + 1).fit(Z).kneighbors(Z, return_distance=False)
    )
    i = rng.integers(len(X_min), size=n_new)  # опорна точка x_i
    j = nbrs[i, 1 + rng.integers(k, size=n_new)]  # сусід x_j; стовпець 0 — сама точка
    lam = rng.random((n_new, 1))  # λ — випадкове число між 0 і 1
    return X_min[i] + lam * (X_min[j] - X_min[i])


X_sm = np.r_[fr_tr, smote(fr_tr[idx_pos], n_new)]
y_sm = np.r_[yfr_tr, np.ones(n_new, bool)]
p_smote = logreg().fit(X_sm, y_sm).predict_proba(fr_te)[:, 1]
print(f"додано {n_new} шахрайських операцій")
for tag, p in [("копії", p_over), ("SMOTE", p_smote)]:
    print(f"{tag:6s} {summary(p)}")

Вивід код запущено, вивід не редагувався

додано 198676 шахрайських операцій
копії  повнота 0.899, точність 0.069, хибних 1788
SMOTE  повнота 0.899, точність 0.069, хибних 1793

На що дивитися: обидва способи дають ту саму повноту 0,899 і майже стільки ж хибних тривог, скільки ваги balanced (1788 і 1793 проти 1804), — для лінійної моделі це три варіанти одного й того самого зсуву межі.

Сусідів ми шукаємо в стандартизованих ознаках, інакше близькість визначала б сума операції. У робочому коді SMOTE не пишуть руками: бібліотека imbalanced-learn дає SMOTE().fit_resample(X, y) і власний конвеєр, у якому SMOTE ставлять після StandardScaler і який робить передискретизацію всередині кожного фолду.

Недодискретизація: менше прикладів частого класу

Недодискретизація (undersampling) робить навпаки: з частого класу випадково лишає стільки прикладів, скільки є в рідкісному. Від 199 020 звичайних операцій лишається 344, і модель навчається на 688 прикладах замість 199 364.

Перевага — швидкість: на величезних даних це інколи єдиний спосіб навчити модель за розумний час. Ціна — 99,8 % звичайних операцій модель не бачить узагалі, тож погано знає, якими вони бувають. Розумніші варіанти відкидають приклади не навмання: наприклад, NearMiss лишає звичайні операції, найближчі до шахрайських, а Tomek links прибирає звичайну операцію з кожної пари найближчих сусідів різних класів (imbalanced-learn · Under-sampling).

Англійські підписи: Decision function / Resampling — межі рішень і навчальні дані. Верхній ряд — вихідні дані (FunctionSampler тут нічого не відкидає), нижній — випадкова недодискретизація RandomUnderSampler: кожного класу лишилося стільки ж, скільки в найрідкіснішому. Три класи, логістична регресія.

Джерело: imbalanced-learn · Compare under-sampling samplers

# продовження: спирається на попередні блоки лекції
keep_neg = np.random.default_rng(0).choice(idx_neg, len(idx_pos), replace=False)
keep = np.r_[keep_neg, idx_pos]
print(f"лишаємо {len(keep)} прикладів із {len(yfr_tr)}: {len(keep) / len(yfr_tr):.2%}")
p_under = logreg().fit(fr_tr[keep], yfr_tr[keep]).predict_proba(fr_te)[:, 1]
print(summary(p_under))

Вивід код запущено, вивід не редагувався

лишаємо 688 прикладів із 199364: 0.35%
повнота 0.892, точність 0.049, хибних 2567

На що дивитися: повнота 0,892, але хибних тривог уже 2567 — більше, ніж у будь-якого іншого способу.

Фокальна втрата: увага до складних прикладів

У перехресній ентропії кожен приклад вносить $-\log p_t$, де $p_t$ — передбачена ймовірність правильного класу ($p_t=p$ для шахрайства і $1-p$ для звичайної операції). Легких прикладів — звичайних операцій, які модель і так упевнено впізнає, — сотні тисяч, і хоч кожен вносить мало, разом вони домінують у сумі. Фокальна втрата (focal loss, Lin et al., 2017) домножує втрату на множник, який гасить легкі приклади:

$$\text{FL}(p_t)=-{\alpha }_t(1-p_t{)}^{\gamma }\log p_t$$

Тут $\gamma \ge 0$ — параметр фокусування, а ${\alpha }_t$ — вага класу, як у зважуванні (у коді нижче ${\alpha }_t=1$). При $\gamma =0$ і ${\alpha }_t=1$ це звичайна перехресна ентропія. Приклад при $\gamma =2$: легкий приклад із $p_t=0,9$ має перехресну ентропію $-\log 0,9=\mathrm{0,105}$, а фокальна втрата — $0,1^2\cdot \mathrm{0,105}=\mathrm{0,001}05$, у 100 разів менше. Складний приклад із $p_t=0,1$: $\mathrm{2,303}$ проти $0,9^2\cdot \mathrm{2,303}=\mathrm{1,865}$ — майже без змін.

Фокальна втрата залежно від імовірності правильного класу $p_t$ для кількох $\gamma$; $\gamma =0$ — перехресна ентропія. Сіра смуга — легкі приклади з $p_t>0,6$, де втрата з ростом $\gamma$ майже зникає; точки — приклад із тексту при $\gamma =2$.

# продовження: спирається на попередні блоки лекції
import torch
from torchvision.ops import sigmoid_focal_loss

z = torch.tensor([np.log(9), -np.log(9)], dtype=torch.float32)  # p_t = 0,9 і 0,1
ones = torch.ones(2)  # обидва приклади — клас 1
bce = torch.nn.functional.binary_cross_entropy_with_logits(z, ones, reduction="none")
fl = sigmoid_focal_loss(
    z, ones, alpha=-1, gamma=2, reduction="none"
)  # alpha=-1: α_t = 1
print(
    "перехресна ентропія:", bce.numpy().round(5), " focal, γ = 2:", fl.numpy().round(5)
)

Вивід код запущено, вивід не редагувався

перехресна ентропія: [0.10536 2.30259]  focal, γ = 2: [1.05000e-03 1.86509e+00]

На що дивитися: на легкому прикладі фокальна втрата (0,00105) у 100 разів менша за перехресну ентропію (0,10536), на складному (1,865 проти 2,303) — майже та сама.

Перевіримо, що це дає на шахрайських операціях: навчимо ту саму логістичну регресію — один лінійний шар у PyTorch — із $\gamma =0$ і з $\gamma =2$.

# продовження: спирається на попередні блоки лекції
sc_fr = StandardScaler().fit(fr_tr)
X_tr_t = torch.tensor(sc_fr.transform(fr_tr), dtype=torch.float32)
X_te_t = torch.tensor(sc_fr.transform(fr_te), dtype=torch.float32)
t_tr = torch.tensor(yfr_tr, dtype=torch.float32)


def train_focal(gamma):  # логістична регресія = один лінійний шар
    torch.manual_seed(0)
    lin = torch.nn.Linear(X_tr_t.shape[1], 1)
    opt = torch.optim.LBFGS(
        lin.parameters(), max_iter=500, line_search_fn="strong_wolfe"
    )

    def closure():
        opt.zero_grad()
        loss = sigmoid_focal_loss(
            lin(X_tr_t)[:, 0], t_tr, alpha=-1, gamma=gamma, reduction="mean"
        )
        loss.backward()
        return loss

    opt.step(closure)
    return torch.sigmoid(lin(X_te_t)[:, 0]).detach().numpy()


for gamma in (0, 2):
    p_focal = train_focal(gamma)  # після циклу лишиться модель із γ = 2
    tn, fp, fn, tp = confusion_matrix(yfr_te, p_focal >= 0.5).ravel()
    print(
        f"γ = {gamma}: повнота {tp / (tp + fn):.3f}, точність {tp / (tp + fp):.3f}, "
        f"середня p {p_focal.mean():.4f}"
    )

Вивід код запущено, вивід не редагувався

γ = 0: повнота 0.622, точність 0.868, середня p 0.0017
γ = 2: повнота 0.574, точність 0.842, середня p 0.0444

На що дивитися: на наших даних модель із γ = 2 знаходить менше шахрайства, ніж із γ = 0 (повнота 0,574 проти 0,622), а середня ймовірність шахрайства зростає з 0,0017 до 0,0444.

Чесний висновок: на лінійній моделі фокальна втрата не допомагає — шахрайства вона знаходить менше, а ймовірності завищує в 26 разів (0,0444 при справжній частці 0,0017). Її придумали для нейронних мереж, що шукають об'єкти на зображеннях (RetinaNet): там на кожне зображення припадає близько 100 тисяч кандидатних ділянок, і майже всі вони — легкий фон. Модель із γ = 0 — це та сама логістична регресія, але без штрафу на ваги, тому її числа трохи відрізняються від scikit-learn.

Джерело: torchvision · sigmoid_focal_loss

Порівняння способів на шахрайських операціях

Зведемо всі способи в одну таблицю. Модель усюди та сама — логістична регресія на тих самих даних; змінюється лише спосіб боротьби з дисбалансом. Тест тут лише ілюструє різницю: обирати спосіб для реальної задачі треба так само, як поріг, — перехресною перевіркою на навчальній частині.

# продовження: спирається на попередні блоки лекції
print(f"{'спосіб':19s} повнота точність пропущ. хибні збиток    AP  сер. p")
for tag, p, t in [
    ("як є, поріг 0,5", p_base, 0.5),
    ("ваги balanced", p_bal, 0.5),
    ("ваги за цінами", p_cw, 0.5),
    ("копії", p_over, 0.5),
    ("SMOTE", p_smote, 0.5),
    ("недодискретизація", p_under, 0.5),
    ("focal loss, γ = 2", p_focal, 0.5),
    ("поріг за ціною", p_base, thr_cost),
]:
    tn, fp, fn, tp = confusion_matrix(yfr_te, p >= t).ravel()
    ap = average_precision_score(yfr_te, p)
    cost = fn * C_FN + fp * C_FP
    print(
        f"{tag:19s} {tp / (tp + fn):7.3f} {tp / (tp + fp):8.3f} {fn:7d} {fp:5d} "
        f"{cost:6d} {ap:5.3f} {p.mean():6.4f}"
    )
print(f"справжня частка шахрайства в тесті: {yfr_te.mean():.4f}")

Вивід код запущено, вивід не редагувався

спосіб              повнота точність пропущ. хибні збиток    AP  сер. p
як є, поріг 0,5       0.601    0.864      59    14   7622 0.728 0.0017
ваги balanced         0.899    0.069      15  1804  10940 0.712 0.0748
ваги за цінами        0.824    0.659      26    63   3643 0.736 0.0082
копії                 0.899    0.069      15  1788  10860 0.711 0.0745
SMOTE                 0.899    0.069      15  1793  10885 0.712 0.0643
недодискретизація     0.892    0.049      16  2567  14883 0.599 0.0981
focal loss, γ = 2     0.574    0.842      63    16   8144 0.734 0.0444
поріг за ціною        0.804    0.744      29    41   3917 0.728 0.0017
справжня частка шахрайства в тесті: 0.0017

На що дивитися: за повнотою виграють balanced, копії й SMOTE (0,899), за збитком — ваги за цінами (3643) і поріг за ціною (3917); AP майже однакова, 0,71–0,74, крім недодискретизації (0,599); правильна середня ймовірність шахрайства, 0,0017, лишається лише у звичайної моделі.

Ліворуч — повнота й точність, праворуч — сумарний збиток на тесті для восьми способів; зеленим — найменший збиток.

Із таблиці — три висновки.

• Більшість способів не покращує модель, а лише зсуває межу. AP — якість упорядкування операцій за ймовірністю — майже однакова в усіх, 0,71–0,74; помітно гірша лише в недодискретизації (0,599), яка викинула 99,8 % даних.
• «Найкращий» спосіб залежить від метрики. За повнотою виграють balanced, копії й SMOTE, але ціною майже 1800 хибних тривог; за збитком — ваги за цінами (3643) і поріг за ціною (3917): обидва вбудовують справжнє співвідношення цін 25,6, а не 579.
• Усі способи, що втручаються в навчання, псують імовірності. Середня передбачена ймовірність шахрайства в balanced — 0,0748, у 43 рази більша за справжню частку 0,0017; навіть ваги за цінами дають 0,0082. Чесними ймовірності лишаються лише у звичайної моделі — їй і ставлять поріг за ціною. Що робити з нечесними ймовірностями — у наступних розділах.

Чесні ймовірності і крива калібрування

Часто потрібне не лише рішення «так чи ні», а сама ймовірність як число: поріг $t^{\ast }$ за цінами помилок, очікувана кількість подій $\sum _n{p}_n$ (скільки клієнтів погодиться, скільки операцій виявиться шахрайськими), ризик, який повідомляють людині. Усе це працює, лише якщо модель калібрована (calibrated): серед об'єктів, яким вона дає ймовірність близько 0,8, подія справді трапляється приблизно у 80 %.

Перевіряють це кривою калібрування (calibration curve). Передбачення розкладають на кошики — групи з близькою ймовірністю. Для кожного кошика $B$ рахують середню передбачену ймовірність ${\overline{p}}_B=\frac{1}{|B|}\sum _{n\in B}{p}_n$ — вона йде по горизонталі — і фактичну частку позитивних ${\overline{y}}_B=\frac{1}{|B|}\sum _{n\in B}{y}_n$ — по вертикалі; $|B|$ — кількість передбачень у кошику. Наприклад, прогнози 0,6 і 0,8 з мітками 1 і 0 дають точку $(0,7;0,5)$: модель обіцяла в середньому 70 %, а подія сталася в половині випадків. Ідеально калібрована модель лежить на діагоналі.

Схема трьох типів кривої. Самовпевнена модель (червона) дає ймовірності, надто близькі до 0 і 1: де вона обіцяє 0,9, подія трапляється рідше. Невпевнена (помаранчева) тисне прогнози до 0,5: де вона обіцяє 0,2, подія трапляється ще рідше.

На 171 пацієнтці криву надійно не побудувати: між 0,1 і 0,9 лежить лише 21 прогноз, тож кошики в середині шкали спиралися б на кілька пацієнток. Тому далі — більший набір.

Міра Брайєра і крива калібрування на банківських даних

Якість імовірностей одним числом підсумовує міра Брайєра (Brier score) — середній квадрат різниці між імовірністю і міткою:

$$\text{BS}=\frac{1}{N}\sum _{n=1}^N(p_n-y_n{)}^2$$

Приклад на чотирьох клієнтах із прогнозами 0,9; 0,2; 0,6; 0,1 і мітками 1, 0, 0, 0: квадрати помилок $(0,9-1{)}^2=0,01$, $(0,2-0{)}^2=0,04$, $(0,6-0{)}^2=0,36$ і $(0,1-0{)}^2=0,01$; їхня сума 0,42, середнє — $\text{BS}=\mathrm{0,105}$. Найдорожче коштує третій клієнт: модель пообіцяла 60 % згоди, а він відмовився. Нуль — ідеал; міра чутлива і до калібрування, і до того, наскільки добре модель розділяє класи. Корисна планка — прогноз, що всім дає справжню частку позитивних $q$: його Брайєр дорівнює $q(1-q)$.

Дані — Bank Marketing (UCI): дзвінки португальського банку з пропозицією депозиту. Ознаки — вік, професія, сімейний стан, освіта, баланс рахунку, кредити, спосіб і дата контакту, історія попередніх кампаній; ціль — згода клієнта на депозит. Шість кошиків тут однакової наповненості.

# продовження: спирається на попередні блоки лекції
from sklearn.calibration import calibration_curve
from sklearn.compose import ColumnTransformer
from sklearn.metrics import brier_score_loss
from sklearn.preprocessing import OneHotEncoder

print("приклад із 4 клієнтів:", brier_score_loss([1, 0, 0, 0], [0.9, 0.2, 0.6, 0.1]))
COLS = (
    "age job marital education default balance housing loan contact day month "
    "duration campaign pdays previous poutcome y"
).split()  # словник ознак із UCI
bm = fetch_openml(data_id=1461, as_frame=True, parser="auto").frame
bm.columns = COLS
y_bm = (bm["y"].astype(str) == "2").astype(int)  # 1 = погодився на депозит
CAT = "job marital education default housing loan contact month poutcome".split()
# duration відкидаємо: вона стає відомою лише після дзвінка
NUM = ["age", "balance", "day", "campaign", "pdays", "previous"]
pre = ColumnTransformer(
    [("c", OneHotEncoder(handle_unknown="ignore"), CAT), ("n", StandardScaler(), NUM)]
)
bm_tr, bm_te, ybm_tr, ybm_te = train_test_split(
    bm[CAT + NUM], y_bm, test_size=0.3, stratify=y_bm, random_state=0
)
print(f"у тесті {len(ybm_te)} клієнтів, згод {ybm_te.mean():.1%}")

logreg_bm = make_pipeline(pre, LogisticRegression(max_iter=2000)).fit(bm_tr, ybm_tr)
proba_bm = logreg_bm.predict_proba(bm_te)[:, 1]
frac, mean_p = calibration_curve(ybm_te, proba_bm, n_bins=6, strategy="quantile")
edges = np.percentile(
    proba_bm, np.linspace(0, 100, 7)
)  # межі, як у strategy="quantile"
counts = np.bincount(np.searchsorted(edges[1:-1], proba_bm), minlength=6)
print("кошик     n   p̄_B    ȳ_B")
for k, (n_b, a, b) in enumerate(zip(counts, mean_p, frac, strict=True), 1):
    print(f"{k:5d} {n_b:5d} {a:6.3f} {b:6.3f}")
print("Брайєр:", round(brier_score_loss(ybm_te, proba_bm), 4))
const = brier_score_loss(ybm_te, np.full(len(ybm_te), ybm_tr.mean()))
print(f"прогноз «усім {ybm_tr.mean():.3f}»: Брайєр {const:.4f}")
print("ROC-AUC:", round(roc_auc_score(ybm_te, proba_bm), 3))

Вивід код запущено, вивід не редагувався

приклад із 4 клієнтів: 0.105
у тесті 13564 клієнтів, згод 11.7%
кошик     n   p̄_B    ȳ_B
    1  2261  0.024  0.033
    2  2261  0.047  0.049
    3  2260  0.073  0.053
    4  2261  0.096  0.083
    5  2260  0.129  0.111
    6  2261  0.346  0.373
Брайєр: 0.0853
прогноз «усім 0.117»: Брайєр 0.1033
ROC-AUC: 0.773

На що дивитися: у тесті 13 564 клієнти й 11,7 % згод, у кожному кошику близько 2260; два останні стовпці майже збігаються — від 0,024 і 0,033 до 0,346 і 0,373. Брайєр моделі 0,0853 проти 0,1033 у прогнозу «усім 11,7 %», хоча впорядковує клієнтів модель посередньо: ROC-AUC 0,773.

Шість кошиків логістичної регресії на тестових клієнтах, пронумерованих за зростанням імовірності; пунктир — ідеальне калібрування.

Кошики лягають майже на діагональ (найбільші відхилення — у третьому, 0,073 проти 0,053, і в шостому, 0,346 проти 0,373), і це не збіг: перехресна ентропія досягає мінімуму саме на справжній імовірності, тож модель, яка правильно описує дані, буде й каліброваною.

Зважування класів псує ймовірності

Контрприклад на тих самих банківських даних: та сама логістична регресія з class_weight='balanced' (розділ «Зважування класів»). Вона навчається так, ніби згод і відмов порівну, тож завищує ймовірність згоди.

# продовження: спирається на попередні блоки лекції
bal = make_pipeline(
    clone(pre), LogisticRegression(max_iter=2000, class_weight="balanced")
)
pb_bal = bal.fit(bm_tr, ybm_tr).predict_proba(bm_te)[:, 1]
print(f"{'модель':9s} ROC-AUC  Брайєр  очікуваних згод")
for tag, p in [("звичайна", proba_bm), ("balanced", pb_bal)]:
    auc, bs = roc_auc_score(ybm_te, p), brier_score_loss(ybm_te, p)
    print(f"{tag:9s} {auc:7.4f} {bs:7.4f} {p.sum():15.0f}")
print(f"насправді згод: {ybm_te.sum()} із {len(ybm_te)}")

Вивід код запущено, вивід не редагувався

модель    ROC-AUC  Брайєр  очікуваних згод
звичайна   0.7729  0.0853            1615
balanced   0.7748  0.1850            5666
насправді згод: 1587 із 13564

На що дивитися: ROC-AUC майже не змінився (0,7729 → 0,7748) — упорядковує клієнтів зважена модель так само добре; але Брайєр зріс з 0,0853 до 0,1850, гірше, ніж у прогнозу «усім 11,7 %», а сума її ймовірностей обіцяє 5666 згод при 1587 справжніх (у звичайної моделі — 1615).

Для банку, який за таким прогнозом планує роботу кол-центру, це помилка в 3,6 раза. Порядок клієнтів правильний, а числа — ні; саме таку модель і лікує калібрування.

Кожна точка — кошик клієнтів: звичайна модель (синім) лежить на діагоналі, зважена (червоним) — далеко праворуч від неї: обіцяє більше згод, ніж буває.

Калібрування: метод Платта та ізотонічна регресія

Калібрування (calibration) — це маленька окрема модель поверх готової: вона вчиться перекладати вихід моделі $s$ (логіт чи іншу оцінку) у справжню ймовірність. Сама модель при цьому не змінюється. Покроково:

1. Навчити модель як завжди.
2. Отримати її оцінки $s$ на даних, яких вона не бачила: на окремій калібрувальній вибірці або прогнозами поза фолдом перехресної перевірки. На навчальних даних не можна — там модель надто впевнена у своїх відповідях.
3. На парах «оцінка $s_n$ — мітка $y_n$» навчити функцію $g$, що переводить оцінку в імовірність.
4. Для нового об'єкта видавати $p=g(s(x))$.

Метод Платта (Platt scaling) бере $g$ у вигляді сигмоїди з двома параметрами:

$$p=\sigma (as+b)$$

Це логістична регресія з однією ознакою $s$: масштаб $a$ і зсув $b$ підбирають мінімізацією перехресної ентропії. Для зваженої моделі банку вийде $a=\mathrm{0,966}$ і $b=-\mathrm{2,006}$ (код — у наступному розділі). Клієнт із логітом $s=0$, якому зважена модель давала рівно 0,5, отримує $\sigma (-\mathrm{2,006})=\mathrm{0,119}$, а клієнт із $s=2$ — $\sigma (\mathrm{0,966}\cdot 2-\mathrm{2,006})=\mathrm{0,482}$ замість 0,881.

Ізотонічна регресія (isotonic regression) замість сигмоїди підбирає будь-яку неспадну функцію $g$, що мінімізує $\sum _n(g(s_n)-y_n{)}^2$. Неспадну — бо калібрування не має міняти порядок: вищій оцінці не можна дати меншу ймовірність. Приклад: клієнти з оцінками 0,3 і 0,4 мають мітки 1 і 0; першому не можна дати більше, ніж другому, тож обидва отримують середнє, 0,5. Ізотонічна регресія гнучкіша за сигмоїду, але вимогливіша до обсягу даних.

Калібрувальні функції для зваженої моделі: по горизонталі — її ймовірність $q$, по вертикалі — відкалібрована $p$; логіт $s=\log (q/(1-q))$. Червоні точки — шість кошиків: що обіцяла зважена модель і яка частка згод була насправді. Сходинки ізотонічної регресії (зелені) проходять майже крізь ці точки, жорсткіша сигмоїда Платта (фіолетова) — поблизу, найдалі від верхнього кошика.

Калібрування лагодить зважену модель

Перевіримо на тих самих даних. Метод Платта напишемо з нуля — це чотири рядки — і порівняємо з бібліотечним CalibratedClassifierCV.

# продовження: спирається на попередні блоки лекції
from sklearn.calibration import CalibratedClassifierCV
from sklearn.model_selection import cross_val_predict

# Платт з нуля: логіти поза фолдом → логістична регресія з однією ознакою
s_oof = cross_val_predict(bal, bm_tr, ybm_tr, cv=5, method="decision_function")
platt = LogisticRegression(C=1e6).fit(s_oof[:, None], ybm_tr)  # практично без штрафу
a, b = platt.coef_[0, 0], platt.intercept_[0]
s_te = bal.fit(bm_tr, ybm_tr).decision_function(bm_te)  # логіти тієї самої моделі
print(f"Платт з нуля: a = {a:.3f}, b = {b:.3f}")
for s in (0, 2):
    print(f"  логіт {s}: було {sigmoid(s):.3f}, стало {sigmoid(a * s + b):.3f}")
lib = {
    m: CalibratedClassifierCV(bal, method=m, ensemble=False).fit(bm_tr, ybm_tr)
    for m in ("sigmoid", "isotonic")
}
c = lib["sigmoid"].calibrated_classifiers_[0].calibrators[0]  # σ(−(a_·s + b_))
print(f"Платт, бібліотека: a = {-c.a_:.3f}, b = {-c.b_:.3f}")
print(f"{'модель':18s} ROC-AUC  Брайєр  середня p")
for tag, p in [
    ("Платт з нуля", sigmoid(a * s_te + b)),
    ("Платт, бібліотека", lib["sigmoid"].predict_proba(bm_te)[:, 1]),
    ("ізотонічна", lib["isotonic"].predict_proba(bm_te)[:, 1]),
]:
    auc, bs = roc_auc_score(ybm_te, p), brier_score_loss(ybm_te, p)
    print(f"{tag:18s} {auc:7.4f} {bs:7.4f} {p.mean():9.3f}")

Вивід код запущено, вивід не редагувався

Платт з нуля: a = 0.966, b = -2.006
  логіт 0: було 0.500, стало 0.119
  логіт 2: було 0.881, стало 0.482
Платт, бібліотека: a = 0.966, b = -2.006
модель             ROC-AUC  Брайєр  середня p
Платт з нуля        0.7748  0.0857     0.119
Платт, бібліотека   0.7748  0.0857     0.119
ізотонічна          0.7746  0.0850     0.119

На що дивитися: Платт із нуля і бібліотека дають ті самі a = 0,966 і b = −2,006; Брайєр падає з 0,1850 до 0,0857, в ізотонічної — до 0,0850, середня ймовірність повертається до 0,119, а ROC-AUC лишається майже тим самим.

Калібрування — монотонне перетворення, тож ROC-AUC його майже не помічає; погане калібрування видно лише за мірою Брайєра чи кривою. Зверніть увагу: $a\approx 1$, а $b\approx -2$ — майже рівно логарифм шансів згоди, $\log (\mathrm{0,117}/\mathrm{0,883})=-2,02$: зважування здебільшого просто зсунуло логіт на цю величину. Бібліотека ще й злегка згладжує мітки 0 і 1, але на 31 тисячі навчальних прикладів різниці не видно. Віджет нижче дозволяє крутити $a$ і $b$ руками. Той самий прийом застосовують і до нейронних мереж, які часто надто впевнені (лекція 10).

Зважена модель до калібрування (червоним) і після нього: метод Платта (фіолетовим) та ізотонічна регресія (зеленим) повертають кошики майже на діагональ.

Метод Платта: два числа лагодять імовірності

Зважена модель на 13 564 тестових клієнтах Bank Marketing. Кожен логіт s перетворюємо на p = σ(a·s + b) і дивимося, куди рушають шість кошиків і як змінюється міра Брайєра.

Масштаб a = 1,000Зсув b = 0,000

без калібрування   поточні a і b   пунктир — ідеальне калібрування

0,1850міра Брайєра

0,418середня p; частка згод 0,117

0,500p при s = 0, тобто σ(b)

0,7748ROC-AUC — однаковий при будь-якому a > 0

Без калібрування зважена модель обіцяє в середньому 0,418 при частці згод 0,117, і всі кошики лежать праворуч від діагоналі; Брайєр 0,1850. Кнопка «Платт» ставить ті a і b, які підібрав CalibratedClassifierCV у коді розділу: кошики лягають на діагональ, Брайєр 0,0857. Клієнт із логітом s = 0, якому зважена модель давала рівно 0,5, тепер отримує σ(−2,006) = 0,119. Третя кнопка лишає a = 1 і зсуває логіт лише на логарифм шансів згоди, log(0,117/0,883) = −2,021, — і дає той самий Брайєр 0,0857: зважування класів здебільшого просто зсунуло логіт на цю величину. Тепер посуньте a: кошики розходяться віялом, а ROC-AUC стоїть на місці — порядок клієнтів той самий.

Зважування класів не замінює правильного порога

Зважування не марне — воно робить непрямо те, що поріг робить прямо, але ламає калібрування, як ми щойно бачили на банківських даних.

Тому поріг 0,0376, обчислений із цін, до зваженої моделі застосовувати не можна — вона дасть 36 834 хибні тривоги. Кожній моделі потрібен свій поріг, підібраний на навчальній частині за прогнозами перехресної перевірки; тест — лише для підсумку.

# продовження: спирається на попередні блоки лекції
from sklearn.model_selection import cross_val_predict


def cost_of(proba, labels, thr):  # збиток і кількість хибних тривог при порозі
    tn, fp, fn, tp = confusion_matrix(labels, proba >= thr).ravel()
    return fn * C_FN + fp * C_FP, fp


def best_threshold(proba, labels):  # перебір усіх порогів за один прохід
    order = np.argsort(-proba)  # тривога всім, чия ймовірність не нижча за поріг
    p, lab = proba[order], labels[order]
    tp, fp = np.cumsum(lab), np.cumsum(~lab)
    last = np.r_[p[1:] != p[:-1], True]  # поріг бере групу однакових p цілком
    costs = np.r_[labels.sum() * C_FN, ((labels.sum() - tp) * C_FN + fp * C_FP)[last]]
    return np.r_[np.inf, p[last]][int(np.argmin(costs))]  # inf — нікому тривоги


cost, alarms = cost_of(p_bal, yfr_te, thr_cost)
print(
    f"зважена модель із порогом за ціною: збиток {cost:.0f}, хибних тривог {alarms:d}"
)
for tag, kw, p_test in [
    ("звичайна", {}, p_base),
    ("зважена", {"class_weight": "balanced"}, p_bal),
]:  # поріг — лише з навчальної частини: прогнози поза фолдом перехресної перевірки
    oof = cross_val_predict(logreg(**kw), fr_tr, yfr_tr, cv=5, method="predict_proba")
    thr = best_threshold(oof[:, 1], yfr_tr)
    test_cost = cost_of(p_test, yfr_te, thr)[0]
    print(f"{tag:9s} поріг {thr:.4f} → збиток на тесті {test_cost:.0f}")

Вивід код запущено, вивід не редагувався

зважена модель із порогом за ціною: збиток 184298, хибних тривог 36834
звичайна  поріг 0.0131 → збиток на тесті 3537
зважена   поріг 0.9763 → збиток на тесті 3665

На що дивитися: із порогом для чесних імовірностей зважена модель дає збиток 184 298, а з власним порогом, підібраним без тесту, майже наздоганяє звичайну — 3665 проти 3537; різниця 128 — це ціна одного пропущеного шахрайства.

Зверніть увагу й на звичайну модель: поріг, підібраний за даними (0,0131), дає менший збиток, ніж формула $t^{\ast }=\mathrm{0,037}6$ (3537 проти 3917). Формула припускає ідеально калібровані ймовірності й однакову ціну пропуску, а на хвості розподілу, де $p\approx 0,01$–$0,04$, ймовірності неточні, і середня сума — лише наближення до ціни кожної операції.

Правило: спершу отримайте чесні ймовірності, потім окремо ухваліть рішення про поріг. Ваги за цінами помилок цьому не суперечать: вони вбудовують справжні ціни, тож рішення при порозі 0,5 виходить добрим, але ймовірності такої моделі вже не чесні, і для будь-якого іншого використання їх доведеться калібрувати.

Мультиклас: one-vs-rest і softmax

Класів може бути більше двох — у наборі Iris їх три. Є два шляхи.

One-vs-rest навчає $K$ незалежних бінарних класифікаторів «клас $k$ проти решти» з виходами $s_k(x)$ і бере клас із найбільшим виходом, $\hat{y}=\arg \underset{k}{max}{s}_k(x)$.

Softmax (мультиноміальна логістична регресія) навчає всі класи спільно: клас $k$ має свій вектор ваг $w_k$, зсув $b_k$ і оцінку (логіт) $z_k=w_k^{\mathrm{\top }}x+b_k$, а ймовірності нормуються разом:

$$p(y=k\mid x)=\frac{\exp (z_k)}{\sum _{j=1}^K\exp (z_j)}$$

Експонента робить кожну оцінку додатною, знаменник нормує їх у суму 1. Наприклад, оцінки $(-2,85;0,86;0,28)$ дають експоненти $(\mathrm{0,058};\mathrm{2,363};\mathrm{1,323})$ із сумою 3,744 і ймовірності $(\mathrm{0,015};\mathrm{0,631};\mathrm{0,353})$; якщо правильний третій клас, перехресна ентропія $-\log \mathrm{0,353}=1,04$. При $K=2$ softmax збігається з логістичною регресією: $e^{z_1}/(e^{z_0}+e^{z_1})=\sigma (z_1-z_0)$.

Джерело оцінок прикладу: Stanford CS231n · Linear Classification

# продовження: спирається на попередні блоки лекції
from sklearn.datasets import load_iris
from sklearn.multiclass import OneVsRestClassifier

iris = load_iris()
Xi = iris.data[:, [0, 3]]  # довжина чашолистка і ширина пелюстки, см
split = train_test_split(
    Xi, iris.target, test_size=0.3, stratify=iris.target, random_state=0
)
Xi_tr, Xi_te, yi_tr, yi_te = split
for tag, clf in [
    ("softmax", LogisticRegression(max_iter=1000)),
    ("one-vs-rest", OneVsRestClassifier(LogisticRegression(max_iter=1000))),
]:
    m = make_pipeline(StandardScaler(), clf).fit(Xi_tr, yi_tr)
    right = int((m.predict(Xi_te) == yi_te).sum())
    print(f"{tag:12s} правильно на тесті: {right} із {len(yi_te)}")

Вивід код запущено, вивід не редагувався

softmax      правильно на тесті: 44 із 45
one-vs-rest  правильно на тесті: 38 із 45

На що дивитися: спільне навчання вгадує 44 квітки з 45 (0,978), незалежні класифікатори — 38 (0,844).

One-vs-rest програє на середньому класі: versicolor лежить між двома іншими, і одна пряма «versicolor проти решти» не відділить його з обох боків — шість його квіток іде до virginica.

Області рішень обох підходів на двох ознаках Iris; точки — усі 150 квіток, у заголовку — частка правильних відповідей на тесті.

Матеріали до розділу

• ⚙scikit-learn · Multiclass and multioutput algorithmsдокументація

  Які моделі підтримують мультиклас напряму, а які загортаються в one-vs-rest.

Softmax: від оцінок до ймовірностей

Три оцінки (логіти) z_k = w_k^⊤x + b_k. Експонента робить їх додатними, ділення на суму — імовірностями. Втрата — −log імовірності правильного класу.

Оцінка класу 1: z₁ = −2,85Оцінка класу 2: z₂ = 0,86Оцінка класу 3: z₃ = 0,28

клас	оцінка z	ez	p = ez / сума
1	−2,85	0,058	0,015
2	0,86	2,363	0,631
3правильний	0,28	1,323	0,353
сума		3,744	1,000

правильний клас:

1,040перехресна ентропія −log p₃

0,641p₂ / (p₂ + p₃): лише класи 2 і 3

0,641σ(z₂ − z₃) = σ(0,58)

Стартові оцінки — з розділу: експоненти 0,058, 2,363 і 1,323 у сумі 3,744 дають імовірності 0,015, 0,631 і 0,353, і за правильного третього класу втрата −log 0,353 = 1,040. Натисніть «додати 2 до всіх»: експоненти зростуть у e² ≈ 7,39 раза, а ймовірності не зміняться — softmax бачить лише різниці оцінок. «Помножити всі на 2» робить розподіл різкішим, так само як довжина вектора ваг робила різкішою сигмоїду. Два останні числа завжди однакові: для пари класів softmax — це сигмоїда від різниці їхніх оцінок. Поверніться до прикладу розділу й оберіть правильним клас 1: модель дає йому лише 0,015, і втрата зростає до 4,17.

Softmax як одношарова мережа

Softmax-регресію зручно бачити як мережу з одного шару: кожен вхід з'єднаний із кожним виходом, а виходів рівно стільки, скільки класів.

У лекції 10 нейронна мережа для класифікації матиме ту саму будову, лише між входом і softmax-шаром з'являться приховані шари, які будують ознаки замість людини; останній шар і функція втрат лишаться тими самими.

Англійські підписи: Input layer — вхідний шар (ознаки x₁–x₄), Output layer — вихідний шар (o₁–o₃, по виходу на клас).

Джерело: Dive into Deep Learning · Softmax Regression

Обмеження логістичної регресії

Межа рішення лише лінійна. Класи, розділені колом чи спіраллю, лінійна модель не розділить. Лікування — нелінійні ознаки вручну, ядрові методи (лекція 07) або нейронні мережі (лекція 10).

Чутливість до масштабу ознак. Без стандартизації результат залежить від того, у яких одиницях виміряна кожна ознака.

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

Імовірності потребують перевірки. Логістична регресія калібрована, лише якщо правильно описує дані, а зважування класів калібрування псує, — тож перевіряйте кривою калібрування.

Матеріали до розділу

• ⚙scikit-learn · Probability calibrationдокументація

  Що робити, коли ймовірності моделі систематично завищені або занижені.

Підсумок лекції

Класифікація не зводиться до регресії. Квадратична втрата карає впевнені правильні відповіді, тому потрібна інша функція втрат.

Ланцюжок «ймовірність → шанси → логарифм шансів» дозволяє моделювати лінійно логарифм шансів, а сигмоїда повертає з нього ймовірність в інтервалі $(0,1)$.

Перехресна ентропія — не довільний вибір, а прямий наслідок максимальної правдоподібності для розподілу Бернуллі. Її градієнт має ту саму форму «прогноз мінус мітка», що й у методі найменших квадратів, і повториться в нейронних мережах.

Оцінювання важливіше за навчання. Частка правильних відповідей обманює при дисбалансі; дивитись треба на матрицю похибок, точність, повноту й криві ROC або точність–повнота. AUC — частка правильно впорядкованих пар — бачить лише порядок оцінок.

Поріг — це рішення про ціну помилки, і в медичній задачі його свідомо зсувають від 0,5.

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

Спершу чесні ймовірності, потім поріг. Калібрування перевіряють кривою, якість імовірностей підсумовує міра Брайєра, а зіпсовані ймовірності лагодить метод Платта чи ізотонічна регресія.

Джерела й додаткові матеріали

Курси, на яких побудовано лекцію

• EPFL CS-433 — лекції 05a і 05b
• UBC CPSC 340 — лекції 18–19: сурогатні втрати, мультиклас

Підручники

• Hastie, Tibshirani, Friedman. The Elements of Statistical Learning — розділ 9: ROC
• Bishop. Pattern Recognition and Machine Learning — розділ 4

Документація

• scikit-learn · Logistic regression
• scikit-learn · Metrics and scoring
• Breast Cancer Wisconsin, UCI
• Bank Marketing, UCI
• Credit Card Fraud Detection, Kaggle
• scikit-learn · Probability calibration
• imbalanced-learn · User guide — передискретизація, SMOTE, недодискретизація

Статті

• Chawla et al. SMOTE: Synthetic Minority Over-sampling Technique, 2002
• Lin et al. Focal Loss for Dense Object Detection, 2017