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

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

import numpy as np

rng = np.random.default_rng(4)
N = 20_000
width  = rng.normal(22.0, 0.9, N)      # millimetres
weight = rng.normal(57.0, 3.0, N)      # grams

z_true = -5.90 + 1.90 * (width - 22.0) + 0.42 * (weight - 57.0)
y = (rng.random(N) < 1 / (1 + np.exp(-z_true))).astype(float)

perm = rng.permutation(N)
train, val, test = perm[:12_000], perm[12_000:16_000], perm[16_000:]

N = 20000  defects = 337  base rate = 0.0169
defects per split = 203 60 74

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

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

Перцептрон повертав знак. Знак не може відрізнити відбракувати від відбракувати, але зовсім трохи, а саме ця різниця потрібна фабриці, щоб вирішити, які деталі людина має перевірити повторно першими.

Тож буквально дотримуйтеся рецепта з Розділу 2. Запишіть, що ви стверджуєте про те, як породжується мітка, візьміть правдоподібність, візьміть логарифм, змініть знак — і маєте втрату. Для результату так/ні твердженням є розподіл Бернуллі: існує ймовірність $p$ того, що деталь дефектна, і

що є лише компактним способом записати «$p$, якщо $y = 1$, і $1-p$, якщо $y = 0$». Візьміть логарифм цього й змініть знак, і втрата для одного прикладу буде

Це бінарна перехресна ентропія. Її не вибрали тому, що вона зручна; це від’ємна логарифмічна правдоподібність єдиного розподілу, який може мати підкидання монети. Іншого варіанта просто не було.

Досі бракує того, звідки береться $p$. Модель обчислює зважену суму $s = \mathbf{w}\cdot\mathbf{x} + b$, тобто дійсне число на всій числовій прямій, а ймовірність має жити в $(0,1)$. Функція, яка переводить одне в інше, — це логістична сигмоїда:

logit -4.0  ->  p = 0.0180        loss when y=1 and p=0.9  : 0.1054
logit -1.0  ->  p = 0.2689        loss when y=1 and p=0.5  : 0.6931
logit  0.0  ->  p = 0.5000        loss when y=1 and p=0.01 : 4.6052
logit  4.0  ->  p = 0.9820

Читайте правий стовпець як прайс-лист. Бути правим із 90 % упевненості коштує 0.105. Відмовитися визначатися коштує 0.693 — це $\log 2$, ціна знизування плечима. Бути впевнено неправим коштує 4.6, у сорок чотири рази більше, і ціна зростає без межі, коли модель стає дедалі впевненішою у помилці. Перехресна ентропія не просто рахує помилки: вона виставляє рахунок за самовпевненість.

Розділ 3 сказав: щоб навчити будь-що, отримайте похідну втрати за кожним параметром. Зробіть це для одного прикладу. З $s = \mathbf{w}\cdot\mathbf{x} + b$ і $p = \sigma(s)$:

Отже, оновлення — це прогноз мінус правда, помножені на вхід. Більше нічого. Ось увесь trainer, тобто descent з Розділу 3 з одним зміненим рядком:

def sigmoid(z):
    return np.where(z >= 0, 1.0 / (1.0 + np.exp(-z)),
                    np.exp(np.minimum(z, 0)) / (1.0 + np.exp(np.minimum(z, 0))))


def fit_logistic(X, y, lr=0.5, epochs=4000):
    w, b = np.zeros(X.shape[1]), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        g = p - y                        
        w -= lr * (X.T @ g) / len(y)     
        b -= lr * g.sum() / len(y)       
    return w, b

np.where у sigmoid — не косметика. Пряме обчислення $1/(1+e^{-s})$ переповнюється для великих від’ємних $s$; гілка вибирає ту алгебраїчно тотожну форму, яка тримає експоненту від’ємною. Це коробка з плаваючою комою з Розділу 2 стягує свій перший борг, а через два розділи вона стягне більший.

Стандартне пояснення, чому перехресна ентропія краща за квадратичну помилку, — аргумент правдоподібності вище: квадратична помилка виходить із припущення про гаусівський шум, мітки не гаусівські, отже не робіть так. Це правильно, але нікого не переконує, бо можна написати $L = (p - y)^2$ поверх сигмоїди, і воно навчатиметься.

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

Цей додатковий $p(1-p)$ — саме той, що раніше скоротився. Тепер він не скорочується, і він прямує до нуля щоразу, коли модель упевнена — зокрема коли модель упевнено помиляється. Обчисліть обидва варіанти для кількох scores для прикладу, справжня мітка якого дорівнює 1:

При $s = -8$ модель помиляється настільки сильно, наскільки це взагалі можливо, а квадратична помилка відповідає gradient, у 1,491 раза меншим за gradient перехресної ентропії. Що гірша помилка, то менше модель з неї вчиться. Натомість gradient перехресної ентропії насичується на $-1$: максимально неправильний прогноз дає максимально великий сигнал — і не більший.

Запустімо перегони. Дві тисячі збалансованих точок, однакові початкові ваги, обрані так, щоб бути впевнено неправильними ($\mathbf{w} = [-6, -6]$), однакова швидкість навчання, відрізняється лише втрата. Обидва запуски оцінюються перехресною ентропією, щоб стовпці були порівнянні.

Перехресна ентропія завершує справу до епохи 50. Квадратична помилка на епосі 100 все ще має 24 % accuracy — і не зрушила з 23 % на епосі 10 — гірше за вгадування, бо стартувала впевнено неправильно, а gradient, який мав би її врятувати, помножили на 0.0007. Вона вибирається приблизно на епосі 500 і приходить у те саме місце. Тож чесний підсумок такий: квадратична помилка поверх сигмоїди не є неправильною; вона повільна саме там, де швидкість найважливіша. На моделі з двома параметрами ви втрачаєте 450 епох. У мережі зі ста шарами, де якийсь unit десь завжди впевнено помиляється, ви втрачаєте весь навчальний запуск.

Три величини, які належно знадобляться в Розділі 8 для perplexity і в Розділі 11 для штрафу, що тримає fine-tuned політику поруч із її референсом. Вони простіші за свою репутацію.²

Ентропія — це середня кількість бітів, яку треба витратити, щоб передати вибірку з розподілу, якщо використовувати найкращий можливий код для нього:

Перехресна ентропія — це те, що ви витрачаєте, коли використовуєте код, побудований для $q$, на даних, які насправді походять із $p$:

KL-дивергенція — це надлишок, марнування в бітах, спричинене вірою в $q$, коли правдою є $p$:

Перевірте всі три на конвеєрі:

test defect rate                                = 0.0185
entropy of that coin                            = 0.1329 bits
cross-entropy of the constant predictor on test = 0.1330 bits
KL(test coin || fair coin)                      = 0.8671 bits
H + KL                                          = 1.0000 bits
cross-entropy of the p=0.5 predictor on test    = 1.0000 bits

Тут видно дві речі. По-перше, модель, яка просто повідомляє базову частку навчального набору, 1.69 %, досягає перехресної ентропії 0.1330 біта, майже точно ентропії тестових міток — як і мусить, бо має правильний розподіл і жодної іншої інформації. Ентропія — це підлога, яку вам купує незнання про конкретний приклад. По-друге, модель, що знизує плечима й каже 0.5, платить рівно 1 біт, а розрив між ними, 0.8671 біта, — це саме KL-дивергенція. $H + D_{\mathrm{KL}} = H(p,q)$ — не тотожність для заучування; це рахунок, який можна бачити в процесі додавання.

І зв’язок назад із навчанням: коли мітка — це один відомий клас, «справжній» розподіл є one-hot, його ентропія дорівнює нулю, і перехресна ентропія дорівнює KL-дивергенції. Мінімізувати перехресну ентропію й тягнути розподіл моделі до істини — одна й та сама дія.

Дефектність — не одна річ. У литті деталь може вийти як недолив (замало матеріалу), облой (забагато, витиснуло з форми) або підпал. Чотири результати — отже, чотири logits, і вони мають стати чотирма ймовірностями, що в сумі дають одиницю. Це softmax:

Він має властивість, яка виглядає випадковістю, а насправді є всією реалізацією:

для будь-якої сталої $c$, бо $e^{z_i + c} = e^{c} e^{z_i}$ і $e^c$ скорочуються зверху й знизу. Значення мають лише різниці між logits. Абсолютний рівень не є інформацією.

На щастя, бо саме абсолютний рівень ламає комп’ютер:

logits            = [800. 801. 799.]
naive softmax     = [nan nan nan]
shifted by -max   = [0.2447 0.6652 0.09  ]
same softmax after adding 1000 to every logit: True

$e^{800}$ переповнює 64-бітний float, сума стає нескінченністю, а нескінченність, поділена на нескінченність, — це nan: не помилка, не аварійне завершення, а тиха діра там, де щойно були три ймовірності. Віднімання максимального logit нічого не змінює математично й змінює все чисельно, бо найбільша експонента стає рівно $e^0 = 1$. Це трюк logsumexp з Розділу 2 у робочому одязі, і кожна серйозна реалізація робить саме так:

def softmax(Z):
    Z = Z - Z.max(axis=1, keepdims=True)   
    E = np.exp(Z)
    return E / E.sum(axis=1, keepdims=True)


def fit_softmax(X, Y, lr=1.0, epochs=6000):
    W, b = np.zeros((X.shape[1], Y.shape[1])), np.zeros(Y.shape[1])
    for _ in range(epochs):
        G = (softmax(X @ W + b) - Y) / len(X)   
        W -= lr * (X.T @ G)
        b -= lr * G.sum(0)
    return W, b

Gradient знову є прогноз мінус правда, тепер із one-hot $Y$. Бінарний випадок увесь час був лише окремим випадком.

Після навчання на 3,000 деталях і тестування на 1,000, із трьома вимірами кожної (ширина, вага, температура розплаву), модель досягає 94.00 % accuracy. Ось що це число приховує:

Модель знаходить менше половини недоливів. Accuracy цього не бачить, бо 86 % деталей у нормі, і правильних відповідей на них достатньо, щоб витягнути середнє. Macro F1 — середнє F1 по класах, яке зважує рідкісний клас так само, як поширений, — дорівнює 0.7983, проти micro F1 0.9400, який за визначенням ідентичний accuracy. Щоразу, коли хтось повідомляє одне число F1, запитайте — яке саме.

На цьому моделювання закінчилося. Решта розділу — про числа.

Візьміть навчену бінарну модель і зробіть два варіанти, помноживши кожен logit на константу: 0.35 для нерішучої версії, 4 для надмірно впевненої. Множення на додатне число не може змінити жоден знак, тож усі три моделі прогнозують точно ту саму мітку для всіх 4,000 тестових деталей. Accuracy не може їх розрізнити. Перехресна ентропія — може без жодних проблем:

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

Це найгостріший спосіб сформулювати різницю між втратою і метрикою. Втрата — це те, що ви оптимізуєте: вона має бути диференційовною й бачить усе, що сказала модель, зокрема наскільки вона була впевнена. Метрика — це те, за чим вас оцінюють: вона може бути step function, бізнес-правилом, підрахунком пропущених дефектів. Це не той самий об’єкт, і вони не завжди погоджуються — тому ви визначаєте обидва до старту й ніколи не дозволяєте втраті підміняти метрику лише тому, що вона зараз на екрані.

Перед будь-якою моделлю — вимога: який score має найлінивіша можлива відповідь? На цьому конвеєрі: завжди казати, що все гаразд:

always-say-fine baseline: accuracy = 0.9815
confusion (tn, fp, fn, tp) = (3926, 0, 74, 0)

98.15 %. Тепер навчена логістична модель із default-порогом 0.5:

logistic @0.5: accuracy=0.9830 precision=0.8000 recall=0.1081 F1=0.1905
confusion (tn, fp, fn, tp) = (3924, 2, 66, 8)

98.30 %. Вона обійшла baseline на 0.15 процентного пункту, і будь-який звіт, що зупиниться на accuracy, назве це перемогою. Матриця помилок показує, що насправді сталося:

Вона знайшла 8 дефектних деталей із 74 і пропустила 66. Три числа називають три способи читати цю таблицю:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Із деталей, які вона позначила, скільки справді були дефектними. Це вартість змарнованих перевірок.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Із дефектних деталей, скільки вона впіймала. Це вартість відправлення поганої деталі клієнту.
• F1 $= 2PR/(P+R) = 0.190$, їхнє гармонійне середнє, яке тримається поруч із меншим із двох і тому відмовляється лестити одному показнику окремо.

Що важливіше, залежить від фабрики, а не від математики: перевірка коштує кілька секунд, а відвантажений дефект коштує повідомлення про відкликання, тож тут домінує recall, і 0.108 — це провал.

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

Читайте стовпець accuracy зверху вниз. Він увесь час падає — з 98.30 % до 65.93 % — тоді як модель переходить від 8 упійманих дефектів до 71 із 74. Усе корисне, що ця модель може зробити, погіршує її accuracy. Команда, яка оптимізує заголовкове число, випустить версію, що не знаходить нічого.

Чому три розбиття, а не два? Бо в той момент, коли ви використовуєте набір прикладів, щоб вибрати будь-що — поріг, learning rate, яку з шести моделей відправити у продакшн, — цей набір уже використано для fitting, і його score перестає бути незміщеним.³ Виміряно на цьому конвеєрі: сканування порога на validation set обирає 0.196, і потім модель отримує F1 = 0.4122 на недоторканому test set. Якби сканування запустили прямо на test set, найкраще досяжне там було б 0.4186 — число, яке ніхто не має права звітувати.

Тут розрив малий, 0.006, бо це один hyperparameter, просканований один раз на 4,000 validation-прикладах. Він зростає з кожним додатковим рішенням і кожним зменшенням validation set. Також зауважте: напрямок в одному запуску не гарантований. Обраний поріг мав 0.3902 на validation і 0.4122 на test, тож цього разу validation його занизив. Зміщення систематичне через багато рішень, а не видиме в одному.⁴

Тепер вправа. Журнал конвеєра приходить із третім стовпцем, station_seconds: скільки часу кожна деталь провела на станції інспекції. Додати його — це зміна в preprocessing на один рядок. Ось що вона робить:

Recall зростає з 10.8 % до 77.0 %. F1 зростає більш ніж учетверо. І зверніть увагу, що зробила accuracy: 98.30 % → 99.20 %, приріст у дев’ять десятих пункту — саме такий тип числа, який у підсумковому слайді округлюють до «приблизно 99 % у будь-якому разі». Accuracy не побачила провалу раніше й тепер не бачить шахрайства.

Перш ніж читати далі: модель шахрує. З’ясуйте як.

station = 1.8 + rng.exponential(0.35, N)                     # a part just passing through
audited = rng.random(N) < 0.006                              # random spot checks
station[audited] += rng.uniform(6.0, 26.0, audited.sum())
station[y == 1] = 9.0 + rng.exponential(7.0, (y == 1).sum())  

Підсвічений рядок — це витік: час перебування дефектної деталі береться з іншого розподілу, бо людина зняла її з конвеєра. Це найпоширеніший серйозний баг у прикладному machine learning, і він має назву: target leakage — інформація в навчальних ознаках, яка не була б доступна в момент, коли треба зробити прогноз.⁵ Він не кидає exception. Він дає краще число. Кожен стимул у проєкті штовхає до того, щоб його залишити.

Захист — одне питання до кожного стовпця: у ту мить, коли мені потрібен цей прогноз, це значення вже існує? На live-конвеєрі station_seconds невідомий, доки деталь не буде перевірено — а саме це модель мала замінити.

Припустімо, ви оцінюєте модель на 20 прикладах, і вона має 17 правильних відповідей. Ви звітуєте 85 %.

17 correct out of 20 -> accuracy 0.8500
  Wilson    95% CI : [0.6396, 0.9476]
  bootstrap 95% CI : [0.7000, 1.0000]
  P(a 65% model scores 17 or more out of 20) = 0.0444
  P(an 85% model scores 17 or more out of 20) = 0.6477

Чесне прочитання 17/20 — десь між 64 % і 95 %. Справжня 65 % модель дає такий результат у 4.4 % випадків — один запуск із двадцяти трьох — і якщо ви спробували жменю prompts і повідомили найкращий, ви самі виготовили цей запуск. Сімнадцять із двадцяти не можуть відрізнити 85 % модель від 65 %.

Два способи поставити інтервал навколо частки, і обидва мають бути у вашому наборі інструментів:

def wilson(k, n, z=1.959963985):
    """95% interval for k successes in n trials. Correct at small n; no simulation."""
    ph, d = k / n, 1 + z * z / n
    centre = (ph + z * z / (2 * n)) / d
    half = z * (ph * (1 - ph) / n + z * z / (4 * n * n)) ** 0.5 / d
    return centre - half, centre + half


def bootstrap_ci(correct, n_resamples=10_000, alpha=0.05, seed=0):
    """95% interval for the mean of any per-example score array. Works on F1 too."""
    rng = np.random.default_rng(seed)
    correct = np.asarray(correct, dtype=float)
    draws = correct[rng.integers(0, len(correct), size=(n_resamples, len(correct)))]
    lo, hi = np.quantile(draws.mean(axis=1), [alpha / 2, 1 - alpha / 2])
    return float(correct.mean()), float(lo), float(hi)

Використовуйте Wilson⁶ для простої частки успіхів; він добре поводиться за будь-якого $n$ і не потребує randomness. Зверніть увагу вище: при $n = 20$ верхній кінець bootstrap дорівнює 1.0000 — повторна вибірка 20 точок легко може витягнути 20 правильних, тож він не може представити інтервал, вужчий за власну гранулярність. Використовуйте bootstrap⁷ там, де формули немає, тобто в більшості цікавих випадків: F1, macro-середні, BLEU, pass@1, score судді на основі rubric. На цьому конвеєрі F1 налаштованої моделі 0.4122 має bootstrap-інтервал [0.3009, 0.5156] — саме це число має з’явитися у звіті, бо точкова оцінка сама по собі запрошує порівняння, яке не здатна підтримати.

Ще одне вимірювання, бо воно змінює те, як слід порівнювати дві моделі. Дві моделі оцінено на тих самих 500 прикладах:

model A: 0.8580  95% CI [0.8260, 0.8880]
model B: 0.8120  95% CI [0.7780, 0.8460]
the two intervals overlap: True
paired difference A-B: 0.0460  95% CI [0.0260, 0.0680]
they disagree on 31 of 500 examples (A right 27, B right 4)

Їхні інтервали перекриваються, і народне правило — перекриті error bars означають відсутність значущої різниці — назвало б порівняння непереконливим. Це не так. Дві моделі працювали на тих самих прикладах, тож правильна величина — це різниця по прикладах, чий інтервал [0.0260, 0.0680], комфортно вище нуля. Вони не погоджуються лише на 31 із 500 items, і A виграє 27 із цих незгод; спільні приклади, легкі й важкі, скорочуються замість додавати шум. Порівнюйте моделі попарно — і дійдете того самого висновку з частки даних.

Тепер у вас є модель, що видає відкалібровані ймовірності, втрата, виведена з твердження про дані, а не вибрана за зручністю, gradient, який буквально є прогноз мінус правда, і — що важливіше — механізм з’ясувати, чи хоч щось із цього працює. Десятирядковий інтервал Wilson вище повторно використовується дослівно: він несе варіанти prompt у Розділі 15, таблиці retrieval у Розділі 19 і golden set у Розділі 29. Bootstrap — це те, до чого ви звертаєтесь, коли формули немає.

Але модель усе ще має один шар. Вона проводить лінію, а Розділ 1 довів на чотирьох рядках XOR, що лінії недостатньо. Виправлення — складати шари: перший шар згинає простір, другий проводить лінію в зігнутому просторі.

Саме там охайний gradient цього розділу закінчується. Усе вище працювало, бо $\partial L/\partial s = p - y$ можна було записати вручну, один раз, для моделі з одним шаром між входом і втратою. Покладіть посередині другий шар — і питання змінить форму: яка похідна втрати за вагою, що взагалі не торкається виходу, — такою, чий вплив доходить лише через інший шар, можливо, кількома шляхами одночасно?

Ця похідна існує. Обчислювати її вручну безнадійно для будь-чого більшого за іграшку, а обчислювати її по одному параметру за раз безнадійно в іншому масштабі. Потрібна процедура, яка дістає кожну похідну в мережі з одного backward pass по тому самому графу, яким щойно пройшов forward pass.

Це Розділ 5, і це двигун, на якому працює решта курсу.

Також варто читати поруч із цим розділом: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 and §4.3, де йдеться про ймовірність, теорію рішень, теорію інформації та лінійну класифікацію в порядку, якого дотримується цей розділ; Murphy, Probabilistic Machine Learning: An Introduction, chapters 6 and 10; Prince, Understanding Deep Learning §5.4–5.7; and Saito and Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — чому AUC, наведений вище, не має бути єдиним threshold-free числом, на яке ви дивитеся, коли 1.7 % деталей дефектні.