Класификация, cross-entropy и как да не се заблудите сами

Същата фабрика като в Глава 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

Три разделения, не две. Причината заслужава собствен раздел и получава такъв по-долу; засега обучавайте върху първото, настройвайте върху второто и не гледайте третото.

Features са стандартизирани — извадена е средната стойност, разделено е на стандартното отклонение — като се използват само статистиките от обучаващия набор, по причината, която Глава 1 показа с границата за сходимост на perceptron: нецентрираните данни правят геометрията враждебна. От кои редове имате право да изчислите тази средна стойност става жив въпрос по-късно в тази глава.

Perceptron връщаше знак. Знакът не може да различи отхвърли от отхвърли, но на косъм, а точно тази разлика е нужна на фабриката, за да реши кои части човек трябва да прегледа повторно първи.

Затова следвайте рецептата от Глава 2 буквално. Запишете какво твърдите за начина, по който се произвежда label, вземете likelihood, вземете log, сменете знака и имате loss. За изход да/не твърдението е Бернулиево разпределение: има вероятност $p$ частта да е дефектна, и

което е просто компактен начин да се напише „$p$ ако $y = 1$, и $1-p$ ако $y = 0$“. Вземете log на това и сменете знака, и loss за един пример е

Това е binary cross-entropy. Не е избрана, защото е удобна; тя е negative log-likelihood на единственото разпределение, което хвърляне на монета може да има. Нищо друго не беше налично.

Още липсва откъде идва $p$. Моделът изчислява претеглена сума $s = \mathbf{w}\cdot\mathbf{x} + b$, която е реално число и покрива цялата права, а вероятността трябва да живее в $(0,1)$. Функцията, която пренася между тях, е logistic sigmoid:

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, четиридесет и четири пъти повече, и цената расте без граница, докато моделът става по-сигурен в грешката си. Cross-entropy не просто брои грешки: тя таксува арогантността.

Глава 3 каза: за да обучите каквото и да е, вземете производната на loss спрямо всеки параметър. Направете го за един пример. С $s = \mathbf{w}\cdot\mathbf{x} + b$ и $p = \sigma(s)$:

Така че update е prediction минус truth, по input. Нищо друго. Ето целия 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$; разклонението избира алгебрично идентичната форма, която държи експонентата отрицателна. Това е кутията за floating-point от Глава 2, която събира първия си дълг, и ще събере по-голям след два раздела.

Стандартното обяснение защо предпочитаме cross-entropy пред squared error е аргументът с likelihood по-горе: squared error получавате, когато допуснете Gaussian noise, labels не са Gaussian, следователно не го правете. Това е вярно и не убеждава никого, защото можете да напишете $L = (p - y)^2$ върху sigmoid и той ще се обучава.

Аргументът, който наистина стига до целта, е за gradient. Поставете squared error върху sigmoid и chain rule дава

Този допълнителен $p(1-p)$ е онзи, който преди се съкрати. Сега не се съкращава и отива към нула винаги когато моделът е уверен — включително когато моделът е уверено грешен. Оценете и двете при няколко score-а за пример, чийто истински label е 1:

При $s = -8$ моделът е възможно най-грешен, а squared error отговаря с gradient 1 491 пъти по-малък от този на cross-entropy. Колкото по-лоша е грешката, толкова по-малко моделът учи от нея. Gradient на cross-entropy междувременно се насища при $-1$: максимално грешно дава максимално голям сигнал, и не по-голям.

Пуснете състезанието. Две хиляди балансирани точки, идентични начални тегла, избрани да са уверено грешни ($\mathbf{w} = [-6, -6]$), идентичен learning rate, различава се само loss. И двата run-а се оценяват с cross-entropy, за да са сравними колоните.

Cross-entropy приключва до epoch 50. Squared error все още е на 24 % accuracy при epoch 100 — и не е мръднал от 23 % при epoch 10 — по-зле от налучкване, защото е започнал уверено грешно, а gradient, който би го спасил, е умножен по 0.0007. Измъква се около epoch 500 и стига до същото място. Така че честното обобщение е, че squared error върху sigmoid не е неправилен; той е бавен точно там, където скоростта има най-голямо значение. При модел с два параметъра губите 450 epochs. При мрежа със сто слоя, където някоя unit някъде винаги е уверено грешна, губите целия training run.

Три величини, нужни както трябва в Глава 8 за perplexity и в Глава 11 за penalty, който държи fine-tuned policy близо до reference. Те са по-лесни от репутацията си.²

Entropy е средният брой битове, които трябва да похарчите, за да комуникирате извадка от разпределение, ако използвате най-добрия възможен код за него:

Cross-entropy е това, което харчите, когато използвате код, построен за $q$, върху данни, които всъщност идват от $p$:

KL divergence е излишъкът — загубата в битове, причинена от това да вярвате в $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 %, постига cross-entropy от 0.1330 бита, почти точно entropy на тестовите labels — както и трябва, защото има правилното разпределение и никаква друга информация. Entropy е подът, който незнанието за конкретния индивид ви купува. Второ, модел, който свива рамене и казва 0.5, плаща точно 1 бит, а разликата между двете, 0.8671 бита, е точно KL divergence. $H + D_{\mathrm{KL}} = H(p,q)$ не е тъждество за запаметяване; това е сметка, която можете да гледате как се натрупва.

И връзката обратно към обучението: когато label е един известен клас, „истинското“ разпределение е one-hot, неговата entropy е нула, и cross-entropy е равна на KL divergence. Минимизирането на cross-entropy и издърпването на разпределението на модела към истината са едно и също действие.

Дефектното не е едно нещо. При формоване част може да излезе като short shot (недостатъчно материал), flash (твърде много, изстискано от матрицата) или burn. Четири изхода, значи четири 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-bit float, сумата става infinity, а infinity, разделено на infinity, е nan — не грешка, не crash, а тих отвор там, където преди имаше три вероятности. Изваждането на максималния 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 отново е prediction минус truth, сега с $Y$ one-hot. Binary случаят през цялото време е бил специален случай.

Обучен върху 3 000 части и тестван върху 1 000, с по три измервания всяка (ширина, тегло, температура на стопилката), той достига 94.00 % accuracy. Ето какво крие това число:

Моделът намира по-малко от половината short shots. Accuracy не може да види това, защото 86 % от частите са наред и правилното им разпознаване е достатъчно, за да носи средната стойност. Macro F1 — средната стойност на F1 по класове, която тежи рядък клас също толкова, колкото и чест — е 0.7983, срещу micro F1 от 0.9400, който по дефиниция е идентичен с accuracy. Когато някой докладва едно F1 число, попитайте кое.

Това е краят на моделирането. Останалата част от главата е за числата.

Вземете обучения binary модел и направете два варианта, като умножите всеки logit по константа: 0.35 за колеблива версия, 4 за свръхуверена. Умножението по положително число не може да промени нито един знак, така че и трите модела предсказват точно един и същ label за всички 4 000 тестови части. Accuracy не може да ги различи. Cross-entropy няма никакъв проблем:

Колебливият модел плаща малък данък за всяка част, включително хилядите, които познава. Свръхувереният почти не плаща, когато е прав, и катастрофално много, когато греши — една част в този тестов набор му струва 27.63 nats сама по себе си. Двата стигат почти до една и съща обща стойност по противоположни маршрути, а обученият модел, чиито вероятности са калибрирани към данните, стои три пъти по-ниско от двата.

Това е най-острият начин да се формулира разликата между loss и metric. Loss е това, което оптимизирате: трябва да е диференцируема и вижда всичко, което моделът е казал, включително колко сигурен е бил. Metric е това, по което ви оценяват: може да е step function, бизнес правило, брой пропуснати дефекти. Те не са един и същ обект и не винаги са съгласни — затова дефинирате и двете, преди да започнете, и никога не оставяте loss да замести metric само защото случайно е на екрана.

Преди всеки модел, изискването: какъв score има най-мързеливият възможен отговор? На тази лента — винаги казвай, че е наред:

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

98.15 %. Сега обученият логистичен модел при default threshold 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, ще го нарече победа. Confusion matrix казва какво всъщност се е случило:

Намерил е 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 е провал.

Но моделът не е проблемът. Threshold е, а threshold не е част от модела — това е бизнес решение, приложено след това върху вероятност. Sweep-нете го:

Четете колоната accuracy надолу. Тя пада през цялото време — от 98.30 % до 65.93 % — докато моделът минава от хващане на 8 дефекта към хващане на 71 от 74. Всяко полезно нещо, което този модел може да направи, влошава accuracy. Екип, който оптимизира заглавното число, би пуснал версията, която не намира нищо.

Защо три разделения, а не две? Защото в момента, в който използвате набор от примери, за да изберете нещо — threshold, learning rate, кой от шест модела да пуснете — този набор е използван за fitting и score-ът му спира да бъде unbiased.³ Измерено на тази лента: sweep на threshold върху validation set избира 0.196, а моделът после получава F1 = 0.4122 върху недокоснатия test set. Ако sweep-ът беше пуснат директно върху test set, най-доброто постижимо там беше 0.4186 — число, което никой няма право да докладва.

Разликата тук е малка, 0.006, защото това е един hyperparameter, sweep-нат веднъж срещу 4 000 validation примера. Тя расте с всяко допълнително решение и с всяко свиване на validation set. Забележете също, че посоката не е гарантирана в един run: избраният threshold получи 0.3902 на validation и 0.4122 на test, така че validation този път го подцени. Bias е систематичен през много решения, не видим в едно.⁴

Сега упражнението. Log-ът на лентата пристига с трета колона, station_seconds: колко дълго всяка част е прекарала на инспекционната станция. Добавянето ѝ е промяна от един ред в preprocessing. Ето какво прави:

Recall скача от 10.8 % на 77.0 %. F1 нараства над четири пъти. И забележете какво направи accuracy: 98.30 % → 99.20 %, печалба от девет десети от пункт, което е от онези числа, които в summary slide се закръглят до „около 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())  

Подчертаният ред е leak: времето на престой на дефектна част се тегли от различно разпределение, защото човек я е свалил от лентата. Това е най-често срещаният сериозен bug в приложното machine learning и има име: target leakage — информация в training features, която не би била налична в момента, когато prediction трябва да бъде направена.⁵ Не хвърля exception. Произвежда по-добро число. Всеки стимул в проекта сочи към това да го запазите.

Защитата е един въпрос, задаван за всяка колона: в момента, в който ми трябва тази prediction, съществува ли вече тази стойност? На жива лента 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 % от случаите — един run на двадесет и три — и ако сте пробвали шепа prompts и сте докладвали най-добрия, сами сте си произвели този run. Седемнадесет от двадесет не могат да различат 85 % модел от 65 % модел.

Два начина да поставите интервал върху rate, и двата трябва да са в инструментариума ви:

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⁶ за обикновен success rate; държи се добре при всяко $n$ и не изисква randomness. Забележете по-горе, че при $n = 20$ горният край на bootstrap е 1.0000 — resampling на 20 точки лесно може да изтегли 20 правилни, така че не може да представи интервал, по-тесен от собствената си гранулярност. Използвайте bootstrap⁷, когато не съществува формула, което е повечето интересни случаи: F1, macro-averages, BLEU, pass@1, score на rubric-based judge. На тази лента F1 0.4122 на настроения модел носи bootstrap интервал [0.3009, 0.5156] — и това е числото, което трябва да се появи в доклада, защото point estimate сам по себе си кани сравнение, което не може да поддържа.

Още едно измерване, защото променя как трябва да сравнявате два модела. Два модела, оценени върху едни и същи 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 от тези несъгласия; споделените примери, лесни и трудни, се съкращават, вместо да добавят шум. Сравнявайте моделите paired и стигате до същия извод с частица от данните.

Вече имате модел, който извежда калибрирани вероятности, loss, изведена от твърдение за данните вместо избрана за удобство, gradient, който буквално е prediction минус truth, и — по-важното — механиката да разберете дали нещо от това работи. Десетредовият Wilson интервал по-горе се използва дословно отново: той носи prompt вариантите в Глава 15, retrieval таблиците в Глава 19 и golden set в Глава 29. Bootstrap е това, към което посягате, когато не съществува формула.

Но моделът все още е един слой. Той чертае линия, а Глава 1 доказа с четири реда XOR, че линия не е достатъчна. Поправката е да stack-нете: първи слой, който огъва пространството, втори, който чертае линията в огънатото пространство.

Точно там подреденият gradient от тази глава се изчерпва. Всичко по-горе работеше, защото $\partial L/\partial s = p - y$ можеше да бъде записано на ръка, веднъж, за модел с един слой между input и loss. Поставете втори слой по средата и въпросът сменя форма: каква е производната на loss спрямо тегло, което изобщо не докосва output — такова, чието влияние пристига само през друг слой, вероятно по няколко пътя едновременно?

Тази производна съществува. Изчисляването ѝ на ръка е безнадеждно за всичко по-голямо от играчка, а изчисляването ѝ параметър по параметър е безнадеждно в друг мащаб. Нужно е процедура, която получава всяка производна в мрежата от един backward pass върху същия graph, по който forward pass току-що е минал.

Това е Глава 5, и тя е двигателят, на който работи останалата част от този курс.

Струва си да четете заедно с тази глава още: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 и §4.3, който покрива probability, decision theory, information theory и linear classification в реда, който тази глава следва; Murphy, Probabilistic Machine Learning: An Introduction, глави 6 и 10; Prince, Understanding Deep Learning §5.4–5.7; и 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 % от частите са дефектни.