Klassifikation, krydsentropi og kunsten ikke at narre dig selv

Samme fabrik som i Kapitel 1, sværere spørgsmål. I stedet for accepter eller afvis er spørgsmålet er denne del defekt — og defekter er sjældne, hvilket gør måledelen af dette kapitel svær og modelleringsdelen bedragerisk let.

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

Tre splits, ikke to. Årsagen fortjener sin egen sektion og får en nedenfor; indtil videre: træn på den første, tun på den anden, og kig ikke på den tredje.

Features er standardiseret — middelværdi trukket fra, divideret med standardafvigelsen — kun ved hjælp af træningsstatistikkerne, af den grund Kapitel 1 demonstrerede med perceptronens konvergensgrænse: ikke-centrerede data gør geometrien fjendtlig. Hvilke rækker du må beregne den middelværdi fra, bliver et levende spørgsmål senere i dette kapitel.

Perceptronen returnerede et fortegn. Et fortegn kan ikke skelne afvis fra afvis, men kun lige akkurat, og den forskel er præcis, hvad en fabrik behøver for at beslutte, hvilke dele et menneske bør inspicere igen først.

Så følg Kapitel 2's opskrift bogstaveligt. Skriv ned, hvad du hævder om, hvordan en label produceres, tag likelihood, tag logaritmen, negér den, og så har du et tab. For et ja/nej-udfald er påstanden en Bernoulli-fordeling: der er en sandsynlighed $p$ for, at delen er defekt, og

hvilket blot er en kompakt måde at skrive "$p$ hvis $y = 1$, og $1-p$ hvis $y = 0$". Tag logaritmen af det, og negér den, og tabet for ét eksempel er

Dette er binær krydsentropi. Den blev ikke valgt, fordi den er praktisk; den er den negative log-likelihood for den eneste fordeling, et møntkast kan have. Der var intet andet til rådighed.

Det, der stadig mangler, er hvor $p$ kommer fra. Modellen beregner en vægtet sum $s = \mathbf{w}\cdot\mathbf{x} + b$, som er et reelt tal og spænder over hele tallinjen, og en sandsynlighed skal leve i $(0,1)$. Funktionen, der flytter mellem dem, er den logistiske 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

Læs højre kolonne som en prisliste. At have ret med 90 % sikkerhed koster 0,105. At nægte at forpligte sig koster 0,693 — hvilket er $\log 2$, prisen for et skuldertræk. At tage selvsikkert fejl koster 4,6, fireogfyrre gange mere, og prisen stiger uden grænse, efterhånden som modellen bliver mere sikker på en fejl. Krydsentropi tæller ikke blot fejl: den opkræver betaling for arrogance.

Kapitel 3 sagde: For at træne hvad som helst skal du finde den afledte af tabet med hensyn til hver parameter. Gør det for ét eksempel. Med $s = \mathbf{w}\cdot\mathbf{x} + b$ og $p = \sigma(s)$:

Så opdateringen er forudsigelse minus sandhed, gange inputtet. Intet andet. Her er hele træneren, som er Kapitel 3's descent med én linje ændret:

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 i sigmoid er ikke kosmetik. At beregne $1/(1+e^{-s})$ direkte giver overflow for store negative $s$; grenen vælger den algebraisk identiske form, der holder eksponenten negativ. Det er Kapitel 2's floating-point-boks, der indkasserer sin første gæld, og den indkasserer en større to sektioner herfra.

Standardforklaringen på at foretrække krydsentropi frem for kvadreret fejl er likelihood-argumentet ovenfor: kvadreret fejl er det, du får ved at antage Gaussisk støj, labels er ikke Gaussiske, derfor lad være. Det er korrekt, og det overbeviser ingen, fordi du kan skrive $L = (p - y)^2$ oven på en sigmoid, og den vil træne.

Argumentet, der lander, handler om gradienten. Læg kvadreret fejl oven på en sigmoid, og kædereglen giver

Den ekstra $p(1-p)$ er den, der gik ud før. Nu gør den ikke, og den går mod nul, når modellen er selvsikker — også når modellen er selvsikkert forkert. Evaluer begge ved nogle få scorer for et eksempel, hvis sande label er 1:

Ved $s = -8$ tager modellen så meget fejl, som det er muligt at tage, og kvadreret fejl svarer med en gradient, der er 1,491 gange mindre end krydsentropiens. Jo værre fejlen er, desto mindre lærer modellen af den. Krydsentropiens gradient mætter imens ved $-1$: maksimalt forkert giver et maksimalt stort signal, og ikke større.

Kør løbet. To tusind balancerede punkter, identiske startvægte valgt til at være selvsikkert forkerte ($\mathbf{w} = [-6, -6]$), identisk læringsrate, kun tabet er forskelligt. Begge kørsler scores med krydsentropi, så kolonnerne kan sammenlignes.

Krydsentropi er færdig ved epoch 50. Kvadreret fejl ligger stadig på 24 % nøjagtighed ved epoch 100 — og havde ikke flyttet sig fra 23 % ved epoch 10 — — værre end at gætte, fordi den startede selvsikkert forkert, og gradienten, der skulle redde den, er blevet ganget med 0,0007. Den slipper fri omkring epoch 500 og ender samme sted. Så den ærlige opsummering er, at kvadreret fejl over en sigmoid ikke er forkert; den er langsom præcis der, hvor hastighed betyder mest. På en model med to parametre mister du 450 epochs. På et netværk med hundrede lag, hvor en eller anden enhed et eller andet sted altid tager selvsikkert fejl, mister du træningskørslen.

Tre størrelser, der skal bruges ordentligt i Kapitel 8 til perplexity og i Kapitel 11 til den straf, der holder en fine-tuned policy tæt på dens reference. De er lettere end deres ry.²

Entropi er det gennemsnitlige antal bits, du skal bruge for at kommunikere et træk fra en fordeling, hvis du bruger den bedst mulige kode til den:

Krydsentropi er det, du bruger, når du anvender en kode bygget til $q$ på data, der faktisk kommer fra $p$:

KL-divergens er overskuddet — spildet, i bits, forårsaget af at tro på $q$, når sandheden er $p$:

Tjek alle tre på båndet:

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

To ting er synlige dér. For det første opnår en model, der blot rapporterer træningens basisrate, 1,69 %, en krydsentropi på 0,1330 bits, næsten præcis entropien for test-labels — som den må, eftersom den har den rigtige fordeling og ingen anden information. Entropi er det gulv, som uvidenhed om individet køber dig. For det andet betaler en model, der trækker på skuldrene og siger 0,5, præcis 1 bit, og afstanden mellem de to, 0,8671 bits, er netop KL-divergensen. $H + D_{\mathrm{KL}} = H(p,q)$ er ikke en identitet, der skal huskes; det er en regning, du kan se blive lagt sammen.

Og forbindelsen tilbage til træning: Når labelen er en enkelt kendt klasse, er den "sande" fordeling one-hot, dens entropi er nul, og krydsentropi er lig med KL-divergensen. At minimere krydsentropi og trække modellens fordeling mod sandheden er den samme handling.

Defekt er ikke én ting. I støbning kan en del komme ud som et short shot (ikke nok materiale), flash (for meget, presset ud af formen) eller burn. Fire udfald, så fire logits, og de skal blive til fire sandsynligheder, der summerer til én. Det er softmax:

Den har en egenskab, der ligner et tilfælde, men som i virkeligheden er hele implementeringen:

for enhver konstant $c$, fordi $e^{z_i + c} = e^{c} e^{z_i}$ og $e^c$ går ud i top og bund. Kun forskelle mellem logits betyder noget. Det absolutte niveau er ikke information.

Heldigvis, for det absolutte niveau er det, der ødelægger computeren:

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}$ giver overflow i en 64-bit float, summen bliver uendelig, og uendelig divideret med uendelig er nan — ikke en fejl, ikke et crash, bare et tavst hul dér, hvor tre sandsynligheder plejede at være. At trække den største logit fra ændrer intet matematisk og alt numerisk, fordi den største eksponent bliver præcis $e^0 = 1$. Det er Kapitel 2's logsumexp-trick i arbejdstøj, og enhver seriøs implementering gør det:

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

Gradienten er igen forudsigelse minus sandhed, nu med $Y$ one-hot. Det binære tilfælde var hele tiden et specialtilfælde.

Trænet på 3.000 dele og testet på 1.000, med tre målinger hver (bredde, vægt, smeltetemperatur), når den 94,00 % nøjagtighed. Her er, hvad det tal skjuler:

Modellen finder færre end halvdelen af short shots. Nøjagtighed kan ikke se det, fordi 86 % af delene er fine, og at få dem rigtigt er nok til at bære gennemsnittet. Macro F1 — gennemsnittet af F1-scorerne per klasse, som vægter en sjælden klasse på samme måde som en almindelig — er 0,7983, mod en micro F1 på 0,9400, som per definition er identisk med nøjagtighed. Når nogen rapporterer ét F1-tal, så spørg hvilket.

Det er det sidste af modelleringen. Resten af kapitlet handler om tallene.

Tag den trænede binære model, og lav to varianter ved at gange hver logit med en konstant: 0,35 for en tøvende version, 4 for en overmodig. At gange med et positivt tal kan ikke ændre noget fortegn, så alle tre modeller forudsiger præcis den samme label for alle 4.000 testdele. Nøjagtighed kan ikke skelne dem fra hinanden. Krydsentropi har ingen problemer overhovedet:

Den tøvende model betaler en lille skat på hver del, inklusive de tusinder, den får rigtigt. Den overmodige er næsten gratis, når den har ret, og katastrofal, når den tager fejl — én del i det testsæt koster den 27,63 nats alene. De to ender på næsten samme total ad modsatte veje, og den trænede model, hvis sandsynligheder er kalibreret til dataene, ligger tre gange under begge.

Dette er den skarpeste måde at beskrive forskellen mellem et tab og en metric. Tabet er det, du optimerer: det skal være differentiabelt, og det ser alt, modellen sagde, inklusive hvor sikker den var. Metric er det, du bliver bedømt på: den kan være en trinfunktion, en forretningsregel, en optælling af oversete defekter. De er ikke det samme objekt, og de er ikke altid enige — derfor definerer du begge, før du starter, og lader aldrig tabet stå i stedet for metric, bare fordi det tilfældigvis er på skærmen.

Før enhver model kommer kravet: hvad scorer det mest dovne mulige svar? På dette bånd: sig altid fin:

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

98,15 %. Nu den trænede logistiske model ved standardgrænsen 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 %. Den slog baseline med 0,15 procentpoint, og enhver rapport, der stopper ved nøjagtighed, vil kalde det en sejr. Forvekslingsmatricen siger, hvad der faktisk skete:

Den fandt 8 defekte dele ud af 74 og lod 66 slippe igennem. Tre tal navngiver de tre måder at læse tabellen på:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Af de dele, den markerede, hvor mange var faktisk defekte. Det er omkostningen ved spildte inspektioner.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Af de defekte dele, hvor mange fangede den. Det er omkostningen ved at sende en dårlig del til en kunde.
• F1 $= 2PR/(P+R) = 0.190$, deres harmoniske middel, som bliver tæt på den mindste af de to og derfor nægter at blive smigret af én af dem alene.

Hvad der betyder noget, afhænger af fabrikken, ikke af matematikken: en inspektion koster nogle få sekunder, og en sendt defekt koster en tilbagekaldelse, så her dominerer recall, og 0,108 er en fiasko.

Men modellen er ikke problemet. Grænsen er, og grænsen er ikke en del af modellen — den er en forretningsbeslutning, der anvendes bagefter på en sandsynlighed. Sweep den:

Læs nøjagtighedskolonnen nedad. Den falder hele vejen — fra 98,30 % til 65,93 % — mens modellen går fra at fange 8 defekter til at fange 71 af 74. Alt nyttigt, denne model kan gøre, gør dens nøjagtighed værre. Et team, der optimerer overskriftstallet, ville shippe versionen, der intet finder.

Hvorfor tre splits og ikke to? Fordi i det øjeblik du bruger et sæt eksempler til at vælge noget — en grænse, en læringsrate, hvilken af seks modeller der skal shippes — er det sæt blevet brugt til fitting, og dets score holder op med at være unbiased.³ Målt på dette bånd: at sweep'e grænsen på valideringssættet vælger 0,196, og modellen scorer derefter F1 = 0,4122 på det urørte testsæt. Havde sweepet kørt direkte på testsættet, var det bedst opnåelige dér 0,4186 — et tal, ingen har ret til at rapportere.

Afstanden er lille her, 0,006, fordi det er én hyperparameter sweepet én gang mod 4.000 valideringseksempler. Den vokser med hver ekstra beslutning og hver indskrænkning af valideringssættet. Bemærk også, at retningen ikke er garanteret i en enkelt kørsel: den valgte grænse scorede 0,3902 på validering og 0,4122 på test, så validering underestimerede den denne gang. Biasen er systematisk på tværs af mange beslutninger, ikke synlig i én.⁴

Nu øvelsen. Båndloggen ankommer med en tredje kolonne, station_seconds: hvor længe hver del tilbragte ved inspektionsstationen. At tilføje den er en ændring på én linje i preprocessingen. Her er, hvad den gør:

Recall går fra 10,8 % til 77,0 %. F1 mere end firedobles. Og læg mærke til, hvad nøjagtighed gjorde: 98,30 % → 99,20 %, en gevinst på ni tiendedele af et point, hvilket er den slags tal, der bliver rundet til "omkring 99 % uanset" på en opsummeringsslide. Nøjagtighed kunne ikke se fiaskoen før og kan nu ikke se bedraget.

Før du læser videre: modellen snyder. Find ud af hvordan.

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

Den markerede linje er lækken: En defekt dels opholdstid trækkes fra en anden fordeling, fordi et menneske tog den af båndet. Dette er den mest almindelige alvorlige bug i anvendt machine learning, og den har et navn: target leakage — information i træningsfeatures, som ikke ville være tilgængelig i det øjeblik, forudsigelsen skal foretages.⁵ Den kaster ingen exception. Den producerer et bedre tal. Ethvert incitament i et projekt peger mod at beholde den.

Forsvaret er ét spørgsmål, stillet til hver kolonne: I det øjeblik jeg har brug for denne forudsigelse, findes denne værdi så allerede? På et live bånd er station_seconds ukendt, indtil efter delen er blevet inspiceret — hvilket er det, modellen skulle erstatte.

Antag, at du scorer en model på 20 eksempler, og den får 17 rigtige. Du rapporterer 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

Den ærlige læsning af 17/20 er et sted mellem 64 % og 95 %. En ægte 65 %-model producerer dette resultat 4,4 % af tiden — én kørsel ud af treogtyve — og hvis du prøvede en håndfuld prompts og rapporterede den bedste, fremstillede du selv den kørsel. Sytten ud af tyve kan ikke skelne en 85 %-model fra en 65 %-model.

To måder at sætte et interval på en rate, og begge hører hjemme i din værktøjskasse:

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)

Brug Wilson⁶ til en almindelig succesrate; den opfører sig pænt ved enhver $n$ og kræver ingen tilfældighed. Bemærk ovenfor, at ved $n = 20$ er bootstrappens øvre ende 1,0000 — resampling af 20 punkter kan let trække 20 korrekte, så den kan ikke repræsentere et interval smallere end sin egen granularitet. Brug bootstrap⁷, hvor der ikke findes nogen formel, hvilket er de fleste interessante tilfælde: F1, makrogennemsnit, BLEU, pass@1, scoren fra en rubrikbaseret dommer. På dette bånd har den tunede models F1 på 0,4122 et bootstrap-interval på [0.3009, 0.5156] — hvilket er det tal, der bør stå i rapporten, fordi punktestimatet alene inviterer til en sammenligning, det ikke kan understøtte.

Én måling mere, fordi den ændrer, hvordan du bør sammenligne to modeller. To modeller scoret på de samme 500 eksempler:

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)

Deres intervaller overlapper, og folkereglen — overlappende fejlstolper betyder ingen signifikant forskel — ville kalde sammenligningen uafklaret. Det er den ikke. De to modeller kørte på de samme eksempler, så den rigtige størrelse er forskellen per eksempel, hvis interval er [0.0260, 0.0680], komfortabelt over nul. De er kun uenige om 31 af 500 items, og A vinder 27 af de uenigheder; de fælles eksempler, lette og svære, går ud i stedet for at tilføje støj. Sammenlign modeller parret, og du når samme konklusion fra en brøkdel af dataene.

Du har nu en model, der outputter kalibrerede sandsynligheder, et tab afledt af en påstand om dataene i stedet for valgt af bekvemmelighed, en gradient, der bogstaveligt er forudsigelse minus sandhed, og — endnu vigtigere — maskineriet til at finde ud af, om noget af det virker. Wilson-intervallet på ti linjer ovenfor genbruges ordret: det bærer prompt-varianterne i Kapitel 15, retrieval-tabellerne i Kapitel 19 og golden set i Kapitel 29. Bootstrap er det, du griber efter, når der ikke findes nogen formel.

Men modellen er stadig ét lag. Den tegner en linje, og Kapitel 1 beviste med fire rækker XOR, at en linje ikke er nok. Løsningen er at stable: et første lag, der bøjer rummet, et andet, der tegner linjen i det bøjede rum.

Det er dér, den ryddelige gradient fra dette kapitel slipper op. Alt ovenfor virkede, fordi $\partial L/\partial s = p - y$ kunne skrives ned i hånden, én gang, for en model med ét lag mellem inputtet og tabet. Sæt et andet lag ind i midten, og spørgsmålet ændrer form: Hvad er den afledte af tabet med hensyn til en vægt, der slet ikke rører outputtet — en hvis indflydelse kun ankommer gennem et andet lag, muligvis ad flere veje på én gang?

Den afledte findes. At beregne den i hånden er håbløst for alt større end et legetøj, og at beregne den én parameter ad gangen er håbløst i en anden skala. Det, der behøves, er en procedure, der får hver afledt i netværket fra én enkelt baglæns passage over den samme graf, som den fremadrettede passage lige gik igennem.

Det er Kapitel 5, og det er motoren, resten af dette kursus kører på.

Også værd at læse sammen med dette kapitel: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 og §4.3, som dækker sandsynlighed, beslutningsteori, informationsteori og lineær klassifikation i den rækkefølge, dette kapitel følger; Murphy, Probabilistic Machine Learning: An Introduction, kapitlerne 6 og 10; Prince, Understanding Deep Learning §5.4–5.7; og Saito og Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — hvorfor AUC'en citeret ovenfor ikke bør være det eneste tærskelfrie tal, du ser på, når 1,7 % af delene er defekte.