Classificació, entropia creuada i com no enganyar-te

La mateixa fàbrica que al capítol 1, pregunta més difícil. En lloc de acceptar o rebutjar, la pregunta és aquesta peça és defectuosa; i els defectes són rars, cosa que fa difícil la meitat de mesura d’aquest capítol i enganyosament fàcil la meitat de modelatge.

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

Tres particions, no dues. El motiu mereix una secció pròpia i la té més avall; de moment, entrena amb la primera, ajusta amb la segona i no miris la tercera.

Les característiques s’estandarditzen —se’n resta la mitjana i es divideixen per la desviació estàndard— fent servir només les estadístiques d’entrenament, pel motiu que el capítol 1 va demostrar amb la cota de convergència del perceptró: les dades no centrades fan que la geometria sigui hostil. De quines files tens permís per calcular aquesta mitjana es convertirà en una pregunta viva més endavant en aquest capítol.

El perceptró retornava un signe. Un signe no pot distingir rebutjar de rebutjar, però per poc, i aquesta diferència és exactament el que necessita una fàbrica per decidir quines peces hauria de reinspeccionar primer una persona.

Així que segueix literalment la recepta del capítol 2. Escriu què afirmes sobre com es produeix una etiqueta, pren la versemblança, pren-ne el logaritme, nega’l, i tens una pèrdua. Per a un resultat de sí/no, l’afirmació és una distribució Bernoulli: hi ha una probabilitat $p$ que la peça sigui defectuosa, i

que és només una manera compacta d’escriure «$p$ si $y = 1$, i $1-p$ si $y = 0$». Pren el logaritme d’això i nega’l, i la pèrdua per a un exemple és

Això és entropia creuada binària. No s’ha triat perquè sigui còmoda; és la log-versemblança negativa de l’única distribució que pot tenir un llançament de moneda. No hi havia res més disponible.

El que encara falta és d’on surt $p$. El model calcula una suma ponderada $s = \mathbf{w}\cdot\mathbf{x} + b$, que és un nombre real i recorre tota la recta, i una probabilitat ha de viure a $(0,1)$. La funció que es mou entre totes dues és la sigmoide logística:

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

Llegeix la columna de la dreta com una llista de preus. Encertar amb un 90 % de confiança costa 0,105. Negar-se a comprometre’s costa 0,693 —que és $\log 2$, el preu d’una arronsada d’espatlles. Equivocar-se amb confiança costa 4,6, quaranta-quatre vegades més, i el preu puja sense límit a mesura que el model es fa més segur d’un error. L’entropia creuada no es limita a comptar errors: cobra l’arrogància.

El capítol 3 deia: per entrenar qualsevol cosa, obtén la derivada de la pèrdua respecte de cada paràmetre. Fes-ho per a un exemple. Amb $s = \mathbf{w}\cdot\mathbf{x} + b$ i $p = \sigma(s)$:

Així que l’actualització és predicció menys veritat, per l’entrada. Res més. Aquí tens l’entrenador complet, que és el descent del capítol 3 amb una sola línia canviada:

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

El np.where dins de sigmoid no és cosmètic. Calcular $1/(1+e^{-s})$ directament desborda per a $s$ grans i negatius; la branca tria la forma algebraicament idèntica que manté l’exponent negatiu. Aquesta és la caixa de coma flotant del capítol 2 cobrant el seu primer deute, i en cobrarà un de més gros d’aquí a dues seccions.

L’explicació estàndard per preferir l’entropia creuada a l’error quadràtic és l’argument de versemblança anterior: l’error quadràtic és el que obtens si assumes soroll gaussià, les etiquetes no són gaussianes, per tant no ho facis. És correcte i no convenç ningú, perquè pots escriure $L = (p - y)^2$ sobre una sigmoide i s’entrenarà.

L’argument que aterra és sobre el gradient. Posa error quadràtic damunt d’una sigmoide i la regla de la cadena dona

Aquest $p(1-p)$ extra és el que abans es cancel·lava. Ara no ho fa, i va a zero sempre que el model té confiança, fins i tot quan el model està equivocat amb confiança. Avalua tots dos en unes quantes puntuacions, per a un exemple l’etiqueta real del qual és 1:

A $s = -8$ el model està tan equivocat com és possible estar-ho, i l’error quadràtic respon amb un gradient 1.491 vegades més petit que el de l’entropia creuada. Com pitjor és l’error, menys n’aprèn el model. El gradient de l’entropia creuada, en canvi, satura a $-1$: estar màximament equivocat produeix un senyal màximament gran, i no més gran.

Fes la cursa. Dos mil punts equilibrats, pesos inicials idèntics triats perquè siguin equivocats amb confiança ($\mathbf{w} = [-6, -6]$), taxa d’aprenentatge idèntica, només canvia la pèrdua. Totes dues execucions es puntuen amb entropia creuada perquè les columnes siguin comparables.

L’entropia creuada ha acabat a l’epoch 50. L’error quadràtic encara és al 24 % d’exactitud a l’epoch 100 —i no s’havia mogut del 23 % a l’epoch 10—, pitjor que endevinar, perquè va començar equivocat amb confiança i el gradient que l’hauria rescatat s’ha multiplicat per 0,0007. S’escapa cap a l’epoch 500 i aterra al mateix lloc. Així que el resum honest és que l’error quadràtic sobre una sigmoide no és incorrecte; és lent exactament on la velocitat importa més. En un model de dos paràmetres perds 450 epochs. En una xarxa amb cent capes, on alguna unitat en algun lloc sempre està equivocada amb confiança, perds l’entrenament sencer.

Tres quantitats, necessàries com cal al capítol 8 per a la perplexitat i al capítol 11 per a la penalització que manté una política amb fine-tuning a prop de la seva referència. Són més fàcils que la fama que tenen.²

Entropia és el nombre mitjà de bits que has de gastar per comunicar una mostra d’una distribució, si fas servir el millor codi possible per a ella:

Entropia creuada és el que gastes quan fas servir un codi construït per a $q$ sobre dades que en realitat venen de $p$:

Divergència KL és l’excés —el malbaratament, en bits— causat per creure $q$ quan la veritat és $p$:

Comprova les tres coses a la cinta:

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

Allà s’hi veuen dues coses. Primer, un model que simplement informa de la taxa base d’entrenament, 1,69 %, aconsegueix una entropia creuada de 0,1330 bits, gairebé exactament l’entropia de les etiquetes de prova, com ha de ser, perquè té la distribució correcta i cap altra informació. L’entropia és el terra que et compra la ignorància sobre l’individu. Segon, un model que s’arronsa d’espatlles i diu 0,5 paga exactament 1 bit, i la diferència entre totes dues coses, 0,8671 bits, és precisament la divergència KL. $H + D_{\mathrm{KL}} = H(p,q)$ no és una identitat per memoritzar; és una factura que pots veure com es va sumant.

I la connexió de tornada a l’entrenament: quan l’etiqueta és una sola classe coneguda, la distribució «veritable» és one-hot, la seva entropia és zero, i l’entropia creuada és igual a la divergència KL. Minimitzar l’entropia creuada i estirar la distribució del model cap a la veritat són el mateix acte.

Defectuós no és una sola cosa. En l’emmotllament, una peça pot sortir com una injecció curta (no prou material), rebava (massa material, espremut fora del motlle), o cremada. Quatre resultats, per tant quatre logits, i s’han de convertir en quatre probabilitats que sumin u. Això és softmax:

Té una propietat que sembla un accident i de fet és tota la implementació:

per a qualsevol constant $c$, perquè $e^{z_i + c} = e^{c} e^{z_i}$ i el $e^c$ es cancel·len a dalt i a baix. Només les diferències entre logits volen dir alguna cosa. El nivell absolut no és informació.

Per sort, perquè el nivell absolut és el que trenca l’ordinador:

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}$ desborda un float de 64 bits, la suma esdevé infinit, i infinit dividit per infinit és nan: no és un error, no és una caiguda, només un forat silenciós on abans hi havia tres probabilitats. Restar el logit màxim no canvia res matemàticament i ho canvia tot numèricament, perquè l’exponent més gran esdevé exactament $e^0 = 1$. És el truc logsumexp del capítol 2 amb la roba de feina posada, i tota implementació seriosa ho fa:

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

El gradient torna a ser predicció menys veritat, ara amb $Y$ one-hot. El cas binari era un cas especial des del principi.

Entrenat amb 3.000 peces i provat amb 1.000, amb tres mesures cadascuna (amplada, pes, temperatura de fusió), arriba a 94,00 % d’exactitud. Això és el que aquest nombre amaga:

El model troba menys de la meitat de les injeccions curtes. L’exactitud no ho pot veure, perquè el 86 % de les peces estan bé i encertar-les n’hi ha prou per sostenir la mitjana. Macro F1 —la mitjana de les puntuacions F1 per classe, que pesa una classe rara igual que una de comuna— és 0,7983, enfront d’un micro F1 de 0,9400 que per definició és idèntic a l’exactitud. Sempre que algú informi d’un sol nombre F1, pregunta quin.

Això és l’últim del modelatge. La resta del capítol va dels nombres.

Agafa el model binari entrenat i fes-ne dues variants multiplicant cada logit per una constant: 0,35 per a una versió dubitativa, 4 per a una de massa confiada. Multiplicar per un nombre positiu no pot canviar cap signe, així que tots tres models prediuen exactament la mateixa etiqueta per a les 4.000 peces de prova. L’exactitud no els pot distingir. L’entropia creuada no té cap problema:

El model dubitatiu paga un petit impost en cada peça, incloses les milers que encerta. El massa confiat és gairebé gratuït quan encerta i catastròfic quan falla: una sola peça d’aquell conjunt de prova li costa 27,63 nats per si sola. Tots dos arriben gairebé al mateix total per rutes oposades, i el model entrenat, les probabilitats del qual estan calibrades a les dades, queda tres vegades per sota de tots dos.

Aquesta és la manera més clara d’expressar la diferència entre una pèrdua i una mètrica. La pèrdua és el que optimitzes: ha de ser diferenciable i veu tot el que ha dit el model, inclòs com de segur n’estava. La mètrica és allò pel qual et jutgen: pot ser una funció esglaó, una regla de negoci, un recompte de defectes no detectats. No són el mateix objecte i no sempre estan d’acord; per això defineixes totes dues coses abans de començar, i mai deixes que la pèrdua substitueixi la mètrica només perquè resulta que és a la pantalla.

Abans de cap model, el requisit: quina puntuació obté la resposta més mandrosa possible? En aquesta cinta, digues sempre que està bé:

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

98,15 %. Ara el model logístic entrenat, amb el llindar per defecte de 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 %. Ha superat la línia base per 0,15 punts percentuals, i qualsevol informe que s’aturi a l’exactitud en dirà una victòria. La matriu de confusió diu què ha passat realment:

Ha trobat 8 peces defectuoses de 74 i n’ha deixat passar 66. Tres nombres anomenen les tres maneres de llegir aquesta taula:

• Precisió $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FP}) = 8/10 = 0.800$. De les peces que ha marcat, quantes eren realment defectuoses. Aquest és el cost de les inspeccions malgastades.
• Recall $= \mathrm{TP}/(\mathrm{TP}+\mathrm{FN}) = 8/74 = 0.108$. De les peces defectuoses, quantes ha capturat. Aquest és el cost d’enviar una peça dolenta a un client.
• F1 $= 2PR/(P+R) = 0.190$, la seva mitjana harmònica, que es manté a prop del més petit dels dos i, per tant, es nega a deixar-se afalagar per un de sol.

Quin importa depèn de la fàbrica, no de les matemàtiques: una inspecció costa uns segons i un defecte enviat costa un avís de retirada, així que aquí domina el recall i 0,108 és un fracàs.

Però el model no és el problema. El llindar sí, i el llindar no forma part del model: és una decisió de negoci aplicada després a una probabilitat. Escombra’l:

Llegeix la columna d’exactitud cap avall. Cau tot el camí —del 98,30 % al 65,93 %— mentre el model passa de capturar 8 defectes a capturar-ne 71 de 74. Tot el que aquest model pot fer d’útil empitjora la seva exactitud. Un equip que optimitzés el nombre del titular enviaria la versió que no troba res.

Per què tres particions i no dues? Perquè en el moment que fas servir un conjunt d’exemples per triar qualsevol cosa —un llindar, una taxa d’aprenentatge, quin de sis models enviar—, aquest conjunt s’ha fet servir per ajustar, i la seva puntuació deixa de ser no esbiaixada.³ Mesurat en aquesta cinta: escombrar el llindar al conjunt de validació tria 0,196, i després el model obté F1 = 0,4122 al conjunt de prova intacte. Si l’escombrat s’hagués fet directament sobre el conjunt de prova, el millor assolible allà era 0,4186, un nombre que ningú té dret a informar.

La diferència aquí és petita, 0,006, perquè és un hiperparàmetre escombrat una vegada contra 4.000 exemples de validació. Creix amb cada decisió extra i cada reducció del conjunt de validació. Observa també que la direcció no està garantida en una sola execució: el llindar triat va puntuar 0,3902 en validació i 0,4122 en prova, així que aquesta vegada la validació el va infraestimar. El biaix és sistemàtic al llarg de moltes decisions, no visible en una.⁴

Ara l’exercici. El registre de la cinta arriba amb una tercera columna, station_seconds: quant de temps ha passat cada peça a l’estació d’inspecció. Afegir-la és un canvi d’una línia al preprocessament. Això és el que fa:

El recall passa del 10,8 % al 77,0 %. L’F1 es multiplica per més de quatre. I fixa’t què ha fet l’exactitud: 98,30 % → 99,20 %, un guany de nou dècimes de punt, que és el tipus de nombre que en una diapositiva de resum s’arrodoneix a «cap al 99 % en tots dos casos». L’exactitud abans no va veure el fracàs i ara no veu el frau.

Abans de continuar: el model fa trampes. Descobreix com.

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

La línia ressaltada és la fuita: el temps d’estada d’una peça defectuosa es mostreja d’una distribució diferent, perquè una persona l’ha tret de la cinta. Aquest és l’error greu més comú en l’aprenentatge automàtic aplicat, i té un nom: target leakage —informació en les característiques d’entrenament que no estaria disponible en el moment en què s’ha de fer la predicció.⁵ No llança cap excepció. Produeix un nombre millor. Tots els incentius d’un projecte apunten a conservar-la.

La defensa és una pregunta, feta a cada columna: en l’instant en què necessito aquesta predicció, aquest valor ja existeix? En una cinta en viu, station_seconds és desconegut fins després que la peça hagi estat inspeccionada, que és justament el que se suposava que el model havia de substituir.

Suposa que puntues un model sobre 20 exemples i n’encerta 17. Informes d’un 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

La lectura honesta de 17/20 és en algun punt entre el 64 % i el 95 %. Un model genuïnament del 65 % produeix aquest resultat el 4,4 % de les vegades —una execució de cada vint-i-tres—, i si vas provar un grapat de prompts i en vas informar el millor, vas fabricar aquesta execució tu mateix. Disset de vint no poden distingir un model del 85 % d’un del 65 %.

Dues maneres de posar un interval a una taxa, i totes dues han de ser al teu equip d’eines:

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)

Fes servir Wilson⁶ per a una taxa d’èxit simple; es comporta bé amb qualsevol $n$ i no necessita aleatorietat. Fixa’t més amunt que a $n = 20$ l’extrem superior del bootstrap és 1,0000: remostrejar 20 punts pot extreure fàcilment 20 de correctes, de manera que no pot representar un interval més estret que la seva pròpia granularitat. Fes servir el bootstrap⁷ quan no existeix cap fórmula, que és la majoria dels casos interessants: F1, macro-mitjanes, BLEU, pass@1, la puntuació d’un jutge basat en rúbrica. En aquesta cinta, l’F1 de 0,4122 del model ajustat porta un interval bootstrap de [0,3009, 0,5156]; aquest és el nombre que hauria d’aparèixer a l’informe, perquè l’estimació puntual tota sola convida a una comparació que no pot sostenir.

Una mesura més, perquè canvia com hauries de comparar dos models. Dos models puntuats sobre els mateixos 500 exemples:

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)

Els seus intervals se solapen, i la regla popular —barres d’error solapades vol dir cap diferència significativa— diria que la comparació és inconclusa. No ho és. Els dos models s’han executat sobre els mateixos exemples, així que la quantitat correcta és la diferència per exemple, l’interval de la qual és [0.0260, 0.0680], còmodament per sobre de zero. Només discrepen en 31 dels 500 elements, i A guanya 27 d’aquests desacords; els exemples compartits, fàcils i difícils igual, es cancel·len en lloc d’afegir soroll. Compara models de manera aparellada, i arribaràs a la mateixa conclusió amb una fracció de les dades.

Ara tens un model que emet probabilitats calibrades, una pèrdua derivada d’una afirmació sobre les dades en lloc de triada per comoditat, un gradient que és literalment predicció menys veritat i —més important encara— la maquinària per esbrinar si res d’això funciona. L’interval de Wilson de deu línies de més amunt es reutilitza literalment: carrega les variants de prompt al capítol 15, les taules de recuperació al capítol 19 i el conjunt d’or al capítol 29. El bootstrap és el que agafes quan no existeix cap fórmula.

Però el model encara és una sola capa. Dibuixa una línia, i el capítol 1 va demostrar amb quatre files de XOR que una línia no n’hi ha prou. La solució és apilar: una primera capa que corbi l’espai, una segona que dibuixi la línia en l’espai corbat.

Aquí és on s’esgota el gradient net d’aquest capítol. Tot el que hi ha més amunt funcionava perquè $\partial L/\partial s = p - y$ es podia escriure a mà, una vegada, per a un model amb una capa entre l’entrada i la pèrdua. Posa una segona capa al mig i la pregunta canvia de forma: quina és la derivada de la pèrdua respecte d’un pes que no toca gens la sortida, un pes la influència del qual arriba només a través d’una altra capa, potser per diversos camins alhora?

Aquesta derivada existeix. Calcular-la a mà és inviable per a qualsevol cosa més gran que una joguina, i calcular-la paràmetre a paràmetre és inviable a una altra escala. El que cal és un procediment que obtingui totes les derivades de la xarxa amb una sola passada enrere sobre el mateix graf que la passada endavant acaba de recórrer.

Això és el capítol 5, i és el motor sobre el qual funciona la resta d’aquest curs.

També val la pena llegir al costat d’aquest capítol: Bishop, Pattern Recognition and Machine Learning §1.2, §1.5, §1.6 i §4.3, que cobreix probabilitat, teoria de la decisió, teoria de la informació i classificació lineal en l’ordre que segueix aquest capítol; Murphy, Probabilistic Machine Learning: An Introduction, capítols 6 i 10; Prince, Understanding Deep Learning §5.4–5.7; i Saito i Rehmsmeier, The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets (PLOS ONE, 2015): per què l’AUC citada més amunt no hauria de ser l’únic nombre independent del llindar que mires quan l’1,7 % de les peces són defectuoses.