Klassificering, cross-entropy och hur du inte lurar dig själv

Samma fabrik som i kapitel 1, svårare fråga. I stället för acceptera eller kassera är frågan är den här delen defekt — och defekter är sällsynta, vilket gör mäthalvan av det här kapitlet svår och modelleringshalvan bedrägligt enkel.

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 uppdelningar, inte två. Skälet förtjänar ett eget avsnitt och får ett nedan; tills vidare, träna på den första, justera på den andra och titta inte på den tredje.

Features standardiseras — medelvärdet subtraheras, dividerat med standardavvikelsen — med endast träningsstatistiken, av det skäl kapitel 1 demonstrerade med perceptronens konvergensgräns: ocentrerad data gör geometrin fientlig. Vilka rader du får beräkna medelvärdet från blir en levande fråga senare i kapitlet.

Perceptronen returnerade ett tecken. Ett tecken kan inte skilja kassera från kassera, men precis bara, och just den skillnaden är exakt vad en fabrik behöver för att avgöra vilka delar en människa ska inspektera om först.

Följ därför receptet från kapitel 2 bokstavligt. Skriv ned vad du påstår om hur en label produceras, ta likelihood, ta loggen, negera den, och du har en förlust. För ett ja/nej-utfall är påståendet en Bernoulli-fördelning: det finns en sannolikhet $p$ att delen är defekt, och

vilket bara är ett kompakt sätt att skriva ”$p$ om $y = 1$, och $1-p$ om $y = 0$”. Ta loggen av det och negera den, så blir förlusten för ett exempel

Det här är binär cross-entropy. Den valdes inte för att den är bekväm; den är den negativa log-likelihood för den enda fördelning ett myntkast kan ha. Något annat fanns inte.

Det som fortfarande saknas är var $p$ kommer ifrån. Modellen beräknar en viktad summa $s = \mathbf{w}\cdot\mathbf{x} + b$, vilket är ett reellt tal och sträcker sig över hela tallinjen, medan en sannolikhet måste ligga i $(0,1)$. Funktionen som flyttar mellan dem är den logistiska sigmoiden:

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 kolumnen till höger som en prislista. Att ha rätt med 90 % säkerhet kostar 0,105. Att vägra bestämma sig kostar 0,693 — vilket är $\log 2$, priset för en axelryckning. Att ha säkert fel kostar 4,6, fyrtiofyra gånger mer, och priset stiger utan gräns när modellen blir mer säker på ett misstag. Cross-entropy räknar inte bara fel: den tar betalt för arrogans.

Kapitel 3 sa: för att träna vad som helst, ta derivatan av förlusten med avseende på varje parameter. Gör det för ett exempel. Med $s = \mathbf{w}\cdot\mathbf{x} + b$ och $p = \sigma(s)$:

Så uppdateringen är förutsägelse minus sanning, gånger input. Inget annat. Här är hela tränaren, vilket är kapitel 3:s descent med en rad ändrad:

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 är inte kosmetik. Att beräkna $1/(1+e^{-s})$ direkt flödar över för stora negativa $s$; grenen väljer den algebraiskt identiska form som håller exponenten negativ. Det här är kapitel 2:s flyttalslåda som kräver in sin första skuld, och den kommer att kräva in en större två avsnitt härifrån.

Standardförklaringen till att föredra cross-entropy framför kvadratfel är likelihood-argumentet ovan: kvadratfel är vad du får om du antar Gaussiskt brus, labels är inte Gaussiska, alltså ska du inte göra det. Det är korrekt och övertygar ingen, eftersom du kan skriva $L = (p - y)^2$ över en sigmoid och den kommer att tränas.

Argumentet som landar handlar om gradient. Lägg kvadratfel ovanpå en sigmoid så ger kedjeregeln

Den extra $p(1-p)$ är den som tog ut sig tidigare. Nu gör den inte det, och den går mot noll när modellen är säker — även när modellen har säkert fel. Utvärdera båda vid några poäng, för ett exempel vars sanna label är 1:

Vid $s = -8$ har modellen så fel som det går att ha, och kvadratfel svarar med en gradient som är 1 491 gånger mindre än cross-entropy:s. Ju värre misstaget är, desto mindre lär sig modellen av det. Cross-entropy:s gradient mättas däremot vid $-1$: maximalt fel ger en maximalt stor signal, och inte större.

Kör loppet. Två tusen balanserade punkter, identiska startvikter valda för att ha säkert fel ($\mathbf{w} = [-6, -6]$), identisk inlärningstakt, bara förlusten skiljer sig. Båda körningarna poängsätts med cross-entropy så att kolumnerna är jämförbara.

Cross-entropy är klar vid epok 50. Kvadratfel ligger fortfarande på 24 % accuracy vid epok 100 — och hade inte rört sig från 23 % vid epok 10 — värre än att gissa, eftersom den började med säkert fel och den gradient som skulle rädda den har multiplicerats med 0,0007. Den kommer loss runt epok 500 och landar på samma plats. Så den ärliga sammanfattningen är att kvadratfel över en sigmoid inte är felaktigt; det är långsamt exakt där hastighet är viktigast. På en modell med två parametrar förlorar du 450 epoker. På ett nätverk med hundra lager, där någon enhet någonstans alltid har säkert fel, förlorar du träningskörningen.

Tre storheter, som behövs ordentligt i kapitel 8 för perplexity och i kapitel 11 för straffet som håller en fine-tuned policy nära sin referens. De är enklare än sitt rykte.²

Entropi är det genomsnittliga antalet bitar du måste lägga på att kommunicera ett drag ur en fördelning, om du använder bästa möjliga kod för den:

Cross-entropy är vad du betalar när du använder en kod byggd för $q$ på data som egentligen kommer från $p$:

KL-divergens är överskottet — slöseriet, i bitar, som orsakas av att tro $q$ när sanningen är $p$:

Kontrollera alla tre på bandet:

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

Två saker syns där. För det första uppnår en modell som helt enkelt rapporterar träningsbasfrekvensen, 1,69 %, en cross-entropy på 0,1330 bitar, nästan exakt entropin för test-labels — vilket den måste, eftersom den har rätt fördelning och ingen annan information. Entropi är golvet som okunskap om individen köper dig. För det andra betalar en modell som rycker på axlarna och säger 0,5 exakt 1 bit, och gapet mellan de två, 0,8671 bitar, är precis KL-divergensen. $H + D_{\mathrm{KL}} = H(p,q)$ är inte en identitet att memorera; det är en faktura du kan se läggas ihop.

Och kopplingen tillbaka till träning: när label är en enda känd klass är den ”sanna” fördelningen one-hot, dess entropi är noll, och cross-entropy är lika med KL-divergensen. Att minimera cross-entropy och dra modellens fördelning mot sanningen är samma handling.

Defekt är inte en sak. Vid formning kan en del komma ut som en short shot (för lite material), flash (för mycket, utpressat ur formen) eller burn. Fyra utfall, alltså fyra logits, och de måste bli fyra sannolikheter som summerar till ett. Det är softmax:

Den har en egenskap som ser ut som en olyckshändelse men i själva verket är hela implementationen:

för valfri konstant $c$, eftersom $e^{z_i + c} = e^{c} e^{z_i}$ och $e^c$ tar ut varandra upptill och nedtill. Bara skillnader mellan logits betyder något. Den absoluta nivån är inte information.

Lyckligtvis, för den absoluta nivån är det som får datorn att gå sönder:

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}$ flödar över en 64-bitars float, summan blir oändlighet, och oändlighet delat med oändlighet är nan — inte ett fel, ingen krasch, bara ett tyst hål där tre sannolikheter brukade finnas. Att subtrahera den största logit ändrar inget matematiskt och allt numeriskt, eftersom den största exponenten blir exakt $e^0 = 1$. Det här är kapitel 2:s logsumexp-trick i arbetskläder, och varje seriös implementation 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

Gradient är återigen förutsägelse minus sanning, nu med $Y$ one-hot. Det binära fallet var ett specialfall hela tiden.

Tränad på 3 000 delar och testad på 1 000, med tre mätningar var (bredd, vikt, smälttemperatur), når den 94,00 % accuracy. Här är vad det talet döljer:

Modellen hittar färre än hälften av short shots. Accuracy kan inte se det, eftersom 86 % av delarna är felfria och att få dem rätt räcker för att bära genomsnittet. Macro F1 — medelvärdet av F1-poängen per klass, som viktar en sällsynt klass lika mycket som en vanlig — är 0,7983, jämfört med micro F1 på 0,9400 som per definition är identisk med accuracy. När någon rapporterar ett enda F1-tal, fråga vilket.

Det var det sista av modelleringen. Resten av kapitlet handlar om talen.

Ta den tränade binära modellen och gör två varianter genom att multiplicera varje logit med en konstant: 0,35 för en tveksam version, 4 för en översäker. Att multiplicera med ett positivt tal kan inte ändra något tecken, så alla tre modeller predikterar exakt samma label för alla 4 000 testdelar. Accuracy kan inte skilja dem åt. Cross-entropy har inga problem alls:

Den tveksamma modellen betalar en liten skatt på varje del, även de tusentals den får rätt. Den översäkra är nästan gratis när den har rätt och katastrofal när den har fel — en enda del i den testuppsättningen kostar den 27,63 nats på egen hand. De två landar på nästan samma total via motsatta vägar, och den tränade modellen, vars sannolikheter är kalibrerade mot datan, ligger tre gånger lägre än båda.

Det här är det skarpaste sättet att formulera skillnaden mellan en förlust och ett mått. Förlusten är det du optimerar: den måste vara deriverbar, och den ser allt modellen sade, inklusive hur säker den var. Måttet är det du bedöms på: det kan vara en stegfunktion, en affärsregel, en räkning av missade defekter. De är inte samma objekt och de är inte alltid överens — därför definierar du båda innan du börjar, och låter aldrig förlusten stå in för måttet bara för att den råkar visas på skärmen.

Före någon modell, kravet: vad får det lataste möjliga svaret för poäng? På det här bandet, säg alltid felfri:

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

98,15 %. Nu den tränade logistiska modellen, vid standardtröskeln 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 baslinjen med 0,15 procentenheter, och varje rapport som stannar vid accuracy kommer att kalla det en vinst. Förväxlingsmatrisen säger vad som faktiskt hände:

Den hittade 8 defekta delar av 74 och släppte igenom 66. Tre tal namnger de tre sätten att läsa tabellen:

• Precision $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. Av delarna den flaggade, hur många var verkligen defekta. Det här är kostnaden för bortslösade inspektioner.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. Av de defekta delarna, hur många fångade den. Det här är kostnaden för att skicka en dålig del till en kund.
• F1 $= 2PR/(P+R) = 0.190$, deras harmoniska medelvärde, som håller sig nära det mindre av de två och därför vägrar smickras av bara det ena.

Vilket som spelar roll beror på fabriken, inte på matematiken: en inspektion kostar några sekunder och en skickad defekt kostar en återkallelse, så här dominerar recall och 0,108 är ett misslyckande.

Men modellen är inte problemet. Tröskeln är det, och tröskeln är inte en del av modellen — den är ett affärsbeslut som appliceras efteråt på en sannolikhet. Svep den:

Läs accuracy-kolumnen nedåt. Den faller hela vägen — från 98,30 % till 65,93 % — medan modellen går från att fånga 8 defekter till att fånga 71 av 74. Varje användbar sak den här modellen kan göra gör dess accuracy sämre. Ett team som optimerar rubriktalet skulle leverera versionen som inte hittar något.

Varför tre uppdelningar och inte två? För att i samma ögonblick som du använder en uppsättning exempel för att välja något — en tröskel, en inlärningstakt, vilken av sex modeller som ska levereras — har den uppsättningen använts för anpassning, och dess poäng slutar vara unbiased.³ Mätt på det här bandet: att svepa tröskeln på valideringsuppsättningen väljer 0,196, och modellen får sedan F1 = 0,4122 på den orörda testuppsättningen. Om svepet hade körts direkt på testuppsättningen var det bästa möjliga där 0,4186 — ett tal ingen har rätt att rapportera.

Gapet är litet här, 0,006, eftersom det är en hyperparameter som svepts en gång mot 4 000 valideringsexempel. Det växer med varje extra beslut och varje krympning av valideringsuppsättningen. Notera också att riktningen inte är garanterad i en enskild körning: den valda tröskeln fick 0,3902 på validering och 0,4122 på test, så validering underskattade den den här gången. Biasen är systematisk över många beslut, inte synlig i ett enda.⁴

Nu övningen. Bandloggen kommer med en tredje kolumn, station_seconds: hur länge varje del var vid inspektionsstationen. Att lägga till den är en rad i preprocessingen. Här är vad den gör:

Recall går från 10,8 % till 77,0 %. F1 mer än fyrdubblas. Och lägg märke till vad accuracy gjorde: 98,30 % → 99,20 %, en vinst på nio tiondelar av en punkt, vilket är den typ av tal som avrundas till ”cirka 99 % oavsett” på en sammanfattningsslide. Accuracy misslyckades med att se misslyckandet tidigare och misslyckas nu med att se fusket.

Innan du läser vidare: modellen fuskar. Ta reda på hur.

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 markerade raden är läckan: en defekt dels uppehållstid dras från en annan fördelning, eftersom en människa tog den av bandet. Det här är den vanligaste allvarliga buggen i tillämpad maskininlärning, och den har ett namn: target leakage — information i tränings-features som inte skulle vara tillgänglig i det ögonblick prediktionen måste göras.⁵ Den kastar inget undantag. Den producerar ett bättre tal. Varje incitament i ett projekt pekar mot att behålla den.

Försvaret är en fråga, ställd till varje kolumn: vid ögonblicket då jag behöver den här prediktionen, finns det här värdet ännu? På ett liveband är station_seconds okänd tills efter att delen har inspekterats — vilket är det modellen skulle ersätta.

Anta att du poängsätter en modell på 20 exempel och den får 17 rätt. Du rapporterar 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 ärliga läsningen av 17/20 är någonstans mellan 64 % och 95 %. En genuin 65 %-modell producerar det här resultatet 4,4 % av gångerna — en körning av tjugotre — och om du provade en handfull prompts och rapporterade den bästa tillverkade du den körningen själv. Sjutton av tjugo kan inte skilja en 85 %-modell från en 65 %-modell.

Två sätt att sätta ett intervall på en frekvens, och båda hör hemma i din verktygslåda:

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)

Använd Wilson⁶ för en vanlig framgångsfrekvens; den beter sig väl vid varje $n$ och behöver ingen slump. Notera ovan att vid $n = 20$ är bootstrapens övre ände 1,0000 — att resampla 20 punkter kan lätt dra 20 korrekta, så den kan inte representera ett intervall smalare än sin egen granularitet. Använd bootstrap⁷ där ingen formel finns, vilket är de flesta intressanta fall: F1, macro-medelvärden, BLEU, pass@1, poängen från en rubric-baserad domare. På det här bandet har den justerade modellens F1 på 0,4122 ett bootstrap-intervall på [0,3009, 0,5156] — vilket är talet som bör stå i rapporten, eftersom punktskattningen ensam inbjuder till en jämförelse den inte kan stödja.

En mätning till, eftersom den ändrar hur du bör jämföra två modeller. Två modeller poängsatta på samma 500 exempel:

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)

Deras intervall överlappar, och folkregeln — överlappande felstaplar betyder ingen signifikant skillnad — skulle kalla jämförelsen ofullständig. Det är den inte. De två modellerna kördes på samma exempel, så den rätta storheten är skillnaden per exempel, vars intervall är [0.0260, 0.0680], bekvämt över noll. De är oense om bara 31 av 500 objekt, och A vinner 27 av de oenigheterna; de gemensamma exemplen, lätta och svåra, tar ut varandra i stället för att lägga till brus. Jämför modeller parat, så når du samma slutsats med en bråkdel av datan.

Du har nu en modell som matar ut kalibrerade sannolikheter, en förlust härledd från ett påstående om datan i stället för vald för bekvämlighet, en gradient som bokstavligen är förutsägelse minus sanning, och — viktigare — maskineriet för att ta reda på om något av det fungerar. Wilson-intervallet på tio rader ovan återanvänds ordagrant: det bär prompt-varianterna i kapitel 15, retrieval-tabellerna i kapitel 19 och golden set i kapitel 29. Bootstrap är det du tar till när ingen formel finns.

Men modellen är fortfarande ett lager. Den drar en linje, och kapitel 1 bevisade med fyra rader XOR att en linje inte räcker. Lösningen är att stapla: ett första lager som böjer rummet, ett andra som drar linjen i det böjda rummet.

Det är där den prydliga gradient från det här kapitlet tar slut. Allt ovan fungerade eftersom $\partial L/\partial s = p - y$ kunde skrivas ned för hand, en gång, för en modell med ett lager mellan input och förlusten. Sätt ett andra lager i mitten och frågan byter form: vad är derivatan av förlusten med avseende på en vikt som inte rör output alls — en vars påverkan bara anländer genom ett annat lager, kanske längs flera vägar samtidigt?

Den derivatan finns. Att beräkna den för hand är hopplöst för allt större än en leksak, och att beräkna den en parameter i taget är hopplöst i en annan skala. Det som behövs är en procedur som får fram varje derivata i nätverket från en enda backward pass över samma graf som forward pass just gick igenom.

Det är kapitel 5, och det är motorn som resten av den här kursen kör på.

Också värt att läsa jämte det här kapitlet: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 och §4.3, som täcker sannolikhet, beslutsteori, informationsteori och linjär klassificering i den ordning kapitlet följer; Murphy, Probabilistic Machine Learning: An Introduction, kapitel 6 och 10; Prince, Understanding Deep Learning §5.4–5.7; och Saito och Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015) — varför AUC som citeras ovan inte bör vara det enda tröskelfria talet du tittar på när 1,7 % av delarna är defekta.