Klasyfikacja, entropia krzyżowa i jak nie oszukiwać samego siebie

Ta sama fabryka co w rozdziale 1, trudniejsze pytanie. Zamiast zaakceptować czy odrzucić, pytanie brzmi czy ta część jest wadliwa — a wady są rzadkie, co sprawia, że pomiarowa połowa tego rozdziału jest trudna, a modelująca połowa zwodniczo łatwa.

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

Trzy podziały, nie dwa. Powód zasługuje na własną sekcję i dostanie ją niżej; na razie trenuj na pierwszym, dostrajaj na drugim i nie zaglądaj do trzeciego.

Cechy są standaryzowane — odejmujemy średnią i dzielimy przez odchylenie standardowe — używając wyłącznie statystyk treningowych, z powodu, który rozdział 1 pokazał na ograniczeniu zbieżności perceptronu: niewycentrowane dane robią geometrię wrogą. To, z których wierszy wolno ci policzyć tę średnią, stanie się żywym pytaniem później w tym rozdziale.

Perceptron zwracał znak. Znak nie umie odróżnić odrzuć od odrzuć, ale ledwo, a właśnie ta różnica jest fabryce potrzebna, żeby zdecydować, które części człowiek powinien sprawdzić ponownie jako pierwsze.

Podążaj więc dosłownie za przepisem z rozdziału 2. Zapisz, co twierdzisz o sposobie powstawania etykiety, weź likelihood, weź log, zaneguj go i masz stratę. Dla wyniku tak/nie twierdzeniem jest rozkład Bernoulliego: istnieje prawdopodobieństwo $p$, że część jest wadliwa, oraz

co jest po prostu zwartym zapisem „$p$ jeśli $y = 1$, oraz $1-p$ jeśli $y = 0$”. Weź logarytm z tego i go zaneguj, a strata dla jednego przykładu wynosi

To jest binarna entropia krzyżowa. Nie wybrano jej dlatego, że jest wygodna; to ujemny log-likelihood jedynego rozkładu, jaki może mieć rzut monetą. Niczego innego nie było do wyboru.

Wciąż brakuje tego, skąd bierze się $p$. Model liczy ważoną sumę $s = \mathbf{w}\cdot\mathbf{x} + b$, która jest liczbą rzeczywistą i obejmuje całą prostą, a prawdopodobieństwo musi mieścić się w $(0,1)$. Funkcją, która przenosi jedno w drugie, jest logistyczna 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

Czytaj prawą kolumnę jak cennik. Mieć rację z pewnością 90 % kosztuje 0,105. Odmowa zajęcia stanowiska kosztuje 0,693 — czyli $\log 2$, cena wzruszenia ramionami. Bycie pewnym siebie i w błędzie kosztuje 4,6, czterdzieści cztery razy więcej, a cena rośnie bez ograniczeń, gdy model staje się coraz bardziej pewny pomyłki. Entropia krzyżowa nie tylko liczy błędy: pobiera opłatę za arogancję.

Rozdział 3 mówił: żeby cokolwiek trenować, uzyskaj pochodną straty względem każdego parametru. Zrób to dla jednego przykładu. Przy $s = \mathbf{w}\cdot\mathbf{x} + b$ i $p = \sigma(s)$:

Aktualizacja to więc predykcja minus prawda, razy wejście. Nic więcej. Oto cały trener, czyli zejście z rozdziału 3 z jedną zmienioną linią:

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 w sigmoid nie jest kosmetyką. Bezpośrednie liczenie $1/(1+e^{-s})$ powoduje overflow dla dużych ujemnych $s$; gałąź wybiera tę algebraicznie identyczną postać, która utrzymuje wykładnik ujemny. To pudełko zmiennoprzecinkowe z rozdziału 2 ściąga swój pierwszy dług, a większy ściągnie za dwie sekcje.

Standardowe wyjaśnienie, czemu przedkłada się entropię krzyżową nad błąd kwadratowy, to argument z likelihood powyżej: błąd kwadratowy dostajesz, zakładając szum Gaussowski, etykiety nie są Gaussowskie, więc tego nie rób. To poprawne i nikogo nie przekonuje, bo możesz zapisać $L = (p - y)^2$ na sigmoid i model będzie się trenował.

Argument, który trafia, dotyczy gradientu. Połóż błąd kwadratowy na sigmoid, a reguła łańcuchowa daje

To dodatkowe $p(1-p)$ jest tym, co wcześniej się zniosło. Teraz się nie znosi i dąży do zera zawsze, gdy model jest pewny — także wtedy, gdy model jest pewny siebie i błędny. Oceń oba dla kilku wyników, dla przykładu, którego prawdziwa etykieta to 1:

Przy $s = -8$ model myli się tak bardzo, jak tylko może, a błąd kwadratowy odpowiada gradientem 1 491 razy mniejszym niż gradient entropii krzyżowej. Im gorsza pomyłka, tym mniej model się z niej uczy. Gradient entropii krzyżowej tymczasem nasyca się przy $-1$: maksymalnie błędna predykcja daje maksymalnie duży sygnał i nie większy.

Uruchom wyścig. Dwa tysiące zbalansowanych punktów, identyczne wagi początkowe wybrane tak, by były pewne siebie i błędne ($\mathbf{w} = [-6, -6]$), identyczny learning rate, różni się tylko strata. Oba przebiegi oceniane są entropią krzyżową, żeby kolumny były porównywalne.

Entropia krzyżowa kończy pracę przed epoką 50. Błąd kwadratowy nadal ma 24 % trafności w epoce 100 — i nie ruszył się z 23 % w epoce 10 — gorzej niż zgadywanie, bo zaczął pewny siebie i błędny, a gradient, który miał go uratować, został pomnożony przez 0.0007. Ucieka dopiero około epoki 500 i ląduje w tym samym miejscu. Uczciwe podsumowanie jest więc takie: błąd kwadratowy na sigmoid nie jest niepoprawny; jest wolny dokładnie tam, gdzie szybkość ma największe znaczenie. W modelu z dwoma parametrami tracisz 450 epok. W sieci ze stu warstwami, gdzie jakaś jednostka gdzieś zawsze jest pewna siebie i błędna, tracisz cały trening.

Trzy wielkości, potrzebne porządnie w rozdziale 8 dla perplexity i w rozdziale 11 dla kary, która trzyma fine-tuned politykę blisko jej referencji. Są łatwiejsze, niż wynika z ich reputacji.²

Entropia to średnia liczba bitów, które musisz wydać, żeby zakomunikować losowanie z rozkładu, jeśli używasz najlepszego możliwego kodu dla tego rozkładu:

Entropia krzyżowa to koszt, który ponosisz, gdy używasz kodu zbudowanego dla $q$ na danych, które w rzeczywistości pochodzą z $p$:

Dywergencja KL to nadwyżka — marnotrawstwo w bitach — spowodowana wiarą w $q$, gdy prawdą jest $p$:

Sprawdź wszystkie trzy na taśmie:

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

Widać tam dwie rzeczy. Po pierwsze, model, który po prostu raportuje bazową częstość z treningu, 1,69 %, osiąga entropię krzyżową 0.1330 bitu, prawie dokładnie entropię etykiet testowych — tak jak musi, skoro ma właściwy rozkład i żadnych innych informacji. Entropia jest podłogą, którą kupuje ci niewiedza o pojedynczym przykładzie. Po drugie, model, który wzrusza ramionami i mówi 0.5, płaci dokładnie 1 bit, a różnica między nimi, 0.8671 bitu, jest dokładnie dywergencją KL. $H + D_{\mathrm{KL}} = H(p,q)$ nie jest tożsamością do zapamiętania; to rachunek, którego narastanie możesz obserwować.

I połączenie z treningiem: gdy etykieta jest jedną znaną klasą, „prawdziwy” rozkład jest one-hot, jego entropia wynosi zero, a entropia krzyżowa równa się dywergencji KL. Minimalizowanie entropii krzyżowej i przyciąganie rozkładu modelu ku prawdzie to ten sam akt.

Wadliwość nie jest jedną rzeczą. Przy formowaniu wtryskowym część może wyjść jako niedolew (za mało materiału), wypływka (za dużo, wyciśnięte z formy) albo przypalenie. Cztery wyniki, więc cztery logits, i muszą stać się czterema prawdopodobieństwami sumującymi się do jednego. To jest softmax:

Ma własność, która wygląda jak przypadek, a w istocie jest całą implementacją:

dla dowolnej stałej $c$, bo $e^{z_i + c} = e^{c} e^{z_i}$ oraz $e^c$ znoszą się na górze i na dole. Znaczenie mają tylko różnice między logits. Poziom bezwzględny nie jest informacją.

Na szczęście, bo poziom bezwzględny jest tym, co psuje komputer:

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}$ przepełnia 64-bitowy float, suma staje się nieskończonością, a nieskończoność podzielona przez nieskończoność to nan — nie błąd, nie awaria, tylko cicha dziura w miejscu, gdzie przed chwilą były trzy prawdopodobieństwa. Odjęcie maksymalnego logit nie zmienia nic matematycznie i wszystko numerycznie, bo największy wykładnik staje się dokładnie $e^0 = 1$. To trik logsumexp z rozdziału 2 w roboczym ubraniu, i każda poważna implementacja go stosuje:

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 znów jest predykcją minus prawda, teraz z $Y$ one-hot. Przypadek binarny od początku był przypadkiem szczególnym.

Wytrenowany na 3000 częściach i przetestowany na 1000, z trzema pomiarami każdej (szerokość, waga, temperatura stopu), osiąga 94,00 % trafności. Oto co ta liczba ukrywa:

Model znajduje mniej niż połowę niedolewów. Trafność tego nie widzi, bo 86 % części jest w porządku, a poprawne rozpoznanie ich wystarcza, by podnieść średnią. Macro F1 — średnia wyników F1 dla poszczególnych klas, ważąca klasę rzadką tak samo jak częstą — wynosi 0.7983, wobec micro F1 równego 0.9400, które z definicji jest identyczne z trafnością. Gdy ktoś raportuje jedną liczbę F1, zapytaj którą.

To koniec modelowania. Reszta rozdziału dotyczy liczb.

Weź wytrenowany model binarny i zrób dwa warianty, mnożąc każdy logit przez stałą: 0,35 dla wersji wahającej się, 4 dla wersji nadmiernie pewnej siebie. Mnożenie przez liczbę dodatnią nie może zmienić żadnego znaku, więc wszystkie trzy modele przewidują dokładnie tę samą etykietę dla wszystkich 4000 części testowych. Trafność nie umie ich odróżnić. Entropia krzyżowa nie ma z tym żadnego problemu:

Model wahający się płaci mały podatek od każdej części, także od tysięcy tych, które rozpoznaje poprawnie. Ten nadmiernie pewny siebie jest prawie darmowy, gdy ma rację, i katastrofalny, gdy jej nie ma — jedna część w tym zbiorze testowym kosztuje go sama 27.63 nata. Oba docierają do prawie tego samego wyniku całkowitego przeciwnymi drogami, a model wytrenowany, którego prawdopodobieństwa są skalibrowane do danych, siedzi trzy razy niżej od obu.

To najostrzejszy sposób sformułowania różnicy między stratą a metryką. Strata jest tym, co optymalizujesz: musi być różniczkowalna i widzi wszystko, co model powiedział, także to, jak bardzo był pewny. Metryka jest tym, według czego jesteś oceniany: może być funkcją skokową, regułą biznesową, liczbą przeoczonych wad. To nie ten sam obiekt i nie zawsze się zgadzają — dlatego definiujesz oba, zanim zaczniesz, i nigdy nie pozwalasz stracie zastąpić metryki tylko dlatego, że akurat jest na ekranie.

Przed jakimkolwiek modelem wymaganie: jaki wynik osiąga najbardziej leniwa możliwa odpowiedź? Na tej taśmie: zawsze mów, że jest dobrze:

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

98,15 %. Teraz wytrenowany model logistyczny, przy domyślnym progu 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 %. Pokonał baseline o 0,15 punktu procentowego, a każdy raport, który zatrzyma się na trafności, nazwie to zwycięstwem. Macierz pomyłek mówi, co naprawdę się stało:

Znalazł 8 wadliwych części z 74 i przepuścił 66. Trzy liczby nazywają trzy sposoby czytania tej tabeli:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Spośród części, które oznaczył, ile naprawdę było wadliwych. To koszt zmarnowanych kontroli.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Spośród wadliwych części, ile złapał. To koszt wysłania złej części do klienta.
• F1 $= 2PR/(P+R) = 0.190$, ich średnia harmoniczna, która pozostaje blisko mniejszej z dwóch wartości i dlatego nie daje się pochlebić tylko jednej z nich.

Co ma znaczenie, zależy od fabryki, nie od matematyki: kontrola kosztuje kilka sekund, a wysłana wada kosztuje akcję serwisową, więc tutaj dominuje recall i 0.108 jest porażką.

Ale problemem nie jest model. Problemem jest próg, a próg nie jest częścią modelu — to decyzja biznesowa zastosowana później do prawdopodobieństwa. Przeskanuj go:

Czytaj kolumnę trafności w dół. Spada przez cały czas — z 98,30 % do 65,93 % — podczas gdy model przechodzi od złapania 8 wad do złapania 71 z 74. Każda użyteczna rzecz, jaką ten model może zrobić, pogarsza jego trafność. Zespół optymalizujący główną liczbę wysłałby wersję, która nie znajduje niczego.

Dlaczego trzy podziały, a nie dwa? Bo w chwili, gdy używasz zbioru przykładów do wybrania czegokolwiek — progu, learning rate, tego, który z sześciu modeli wysłać — ten zbiór został użyty do dopasowania, a jego wynik przestaje być nieobciążony.³ Zmierzone na tej taśmie: przemiatanie progu na zbiorze walidacyjnym wybiera 0.196, a model osiąga potem F1 = 0.4122 na nietkniętym zbiorze testowym. Gdyby przemiatanie uruchomiono bezpośrednio na zbiorze testowym, najlepszy osiągalny tam wynik wynosił 0.4186 — liczba, której nikt nie ma prawa raportować.

Różnica jest tu mała, 0.006, bo to jeden hyperparameter przemiotany raz wobec 4000 przykładów walidacyjnych. Rośnie z każdą dodatkową decyzją i każdym zmniejszeniem zbioru walidacyjnego. Zauważ też, że kierunek nie jest gwarantowany w pojedynczym przebiegu: wybrany próg uzyskał 0.3902 na walidacji i 0.4122 na teście, więc walidacja tym razem go zaniżyła. Obciążenie jest systematyczne na wielu decyzjach, nie widoczne w jednej.⁴

Teraz ćwiczenie. Log z taśmy przychodzi z trzecią kolumną, station_seconds: ile czasu każda część spędziła na stanowisku kontroli. Dodanie jej to jednolinijkowa zmiana w preprocessingu. Oto co robi:

Recall rośnie z 10,8 % do 77,0 %. F1 rośnie ponad czterokrotnie. I zauważ, co zrobiła trafność: 98,30 % → 99,20 %, zysk dziewięciu dziesiątych punktu, czyli liczba, którą w slajdzie podsumowującym zaokrągla się do „około 99 % w obie strony”. Trafność wcześniej nie zobaczyła porażki, a teraz nie widzi oszustwa.

Zanim czytasz dalej: model oszukuje. Znajdź jak.

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

Podświetlona linia jest leak: czas przebywania wadliwej części jest losowany z innego rozkładu, bo człowiek zdjął ją z taśmy. To najczęstszy poważny błąd w stosowanym uczeniu maszynowym i ma nazwę: target leakage — informacja w cechach treningowych, która nie byłaby dostępna w momencie, gdy trzeba wykonać predykcję.⁵ Nie rzuca wyjątku. Produkuje lepszą liczbę. Każdy bodziec w projekcie pcha w stronę jej zostawienia.

Obrona to jedno pytanie zadawane każdej kolumnie: czy w chwili, gdy potrzebuję tej predykcji, ta wartość już istnieje? Na żywej taśmie station_seconds jest nieznane aż do momentu po kontroli części — czyli po tym, co model miał zastąpić.

Załóżmy, że oceniasz model na 20 przykładach i ma 17 poprawnych. Raportujesz 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

Uczciwe odczytanie 17/20 to gdzieś między 64 % a 95 %. Prawdziwie 65-procentowy model daje taki wynik w 4,4 % przypadków — jeden przebieg na dwadzieścia trzy — a jeśli wypróbowałeś garść prompts i zaraportowałeś najlepszy, sam wyprodukowałeś sobie taki przebieg. Siedemnaście z dwudziestu nie odróżnia modelu 85 % od modelu 65 %.

Dwa sposoby na przedział dla odsetka, i oba należą do twojego zestawu narzędzi:

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)

Używaj Wilsona⁶ dla zwykłego odsetka sukcesów; zachowuje się dobrze przy dowolnym $n$ i nie potrzebuje losowości. Zauważ wyżej, że przy $n = 20$ górny koniec bootstrap wynosi 1.0000 — ponowne próbkowanie 20 punktów może łatwo wylosować 20 poprawnych, więc nie potrafi reprezentować przedziału węższego niż własna ziarnistość. Używaj bootstrap⁷ tam, gdzie nie istnieje wzór, czyli w większości interesujących przypadków: F1, średnie macro, BLEU, pass@1, wynik sędziego opartego na rubryce. Na tej taśmie F1 dostrojonego modelu równe 0.4122 ma przedział bootstrap [0.3009, 0.5156] — i to liczba, która powinna pojawić się w raporcie, bo sam estymator punktowy zaprasza do porównania, którego nie potrafi wesprzeć.

Jeszcze jeden pomiar, bo zmienia to, jak należy porównywać dwa modele. Dwa modele ocenione na tych samych 500 przykładach:

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)

Ich przedziały się nakładają, a ludowa reguła — nakładające się paski błędu oznaczają brak istotnej różnicy — uznałaby porównanie za nierozstrzygające. Nie jest. Oba modele działały na tych samych przykładach, więc właściwą wielkością jest różnica per przykład, której przedział to [0.0260, 0.0680], wygodnie powyżej zera. Nie zgadzają się tylko w 31 z 500 elementów, a A wygrywa 27 z tych niezgodności; wspólne przykłady, łatwe i trudne, znoszą się zamiast dodawać szum. Porównuj modele parami, a dojdziesz do tego samego wniosku na ułamku danych.

Masz teraz model, który wypisuje skalibrowane prawdopodobieństwa, stratę wyprowadzoną z twierdzenia o danych zamiast wybraną dla wygody, gradient będący dosłownie predykcją minus prawda oraz — co ważniejsze — mechanikę sprawdzania, czy cokolwiek z tego działa. Dziesięciolinijkowy przedział Wilsona powyżej jest używany dosłownie ponownie: niesie warianty prompt w rozdziale 15, tabele retrieval w rozdziale 19 i golden set w rozdziale 29. Bootstrap to narzędzie, po które sięgasz, gdy nie istnieje wzór.

Ale model wciąż ma jedną warstwę. Rysuje linię, a rozdział 1 udowodnił na czterech wierszach XOR, że linia nie wystarcza. Naprawą jest układanie w stos: pierwsza warstwa, która zakrzywia przestrzeń, druga, która rysuje linię w zakrzywionej przestrzeni.

To tam schludny gradient z tego rozdziału się kończy. Wszystko powyżej działało, bo $\partial L/\partial s = p - y$ dało się zapisać ręcznie, raz, dla modelu z jedną warstwą między wejściem a stratą. Wstaw drugą warstwę pośrodku, a pytanie zmienia kształt: jaka jest pochodna straty względem wagi, która w ogóle nie dotyka wyjścia — takiej, której wpływ dociera tylko przez inną warstwę, być może kilkoma ścieżkami naraz?

Ta pochodna istnieje. Liczenie jej ręcznie jest beznadziejne dla czegokolwiek większego niż zabawka, a liczenie jej po jednym parametrze naraz jest beznadziejne w innej skali. Potrzebna jest procedura, która uzyskuje każdą pochodną w sieci z jednego backward pass po tym samym grafie, którym przed chwilą przeszedł forward pass.

To jest rozdział 5, i to silnik, na którym jedzie reszta tego kursu.

Warto też czytać równolegle z tym rozdziałem: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 i §4.3, który omawia prawdopodobieństwo, teorię decyzji, teorię informacji i klasyfikację liniową w kolejności, za którą idzie ten rozdział; Murphy, Probabilistic Machine Learning: An Introduction, rozdziały 6 i 10; Prince, Understanding Deep Learning §5.4–5.7; oraz Saito i Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — dlaczego AUC cytowane wyżej nie powinno być jedyną liczbą bezprogową, na którą patrzysz, gdy 1,7 % części jest wadliwych.