Fer que entreni i que generalitzi

Comença mirant, en lloc d’endevinar. Fes passar un batch d’entrades i imprimeix la desviació estàndard de les activacions a cada capa, i després la desviació estàndard dels gradients dels pesos:

def profile(model, x):
    h = x
    for layer in model:
        h = layer(h)
        if isinstance(layer, (nn.Tanh, nn.ReLU)):
            print(f"activation std: {h.std().item():.4f}")
    model(x).sum().backward()
    for p in model.parameters():
        if p.dim() == 2:
            print(f"gradient std: {p.grad.std().item():.2e}")

Tres inicialitzacions, mateixa arquitectura, sis capes de $\tanh$:

La primera fila és la xarxa d’abans, i no està aprenent lentament: ja no li queda cap senyal. A la quarta capa, la desviació estàndard de l’activació ha fet underflow fins a zero amb quatre decimals. Cada entrada produeix la mateixa sortida, la sortida és una constant, i el gradient d’una constant no és res. Els pesos es van inicialitzar petits «per anar sobre segur», i petit va ser fatal.

La segona fila és el fracàs oposat i val la pena entendre’l perquè és contraintuïtiu. Les activacions semblen sanes —al voltant de 0.96—, però això és $\tanh$ saturat, fixat prop del seu límit, exactament el règim que el capítol 5 va mesurar com una pèrdua d’un factor de gairebé deu mil en el gradient. I, tanmateix, els gradients són enormes: 1940 a la primera capa. Totes dues coses són certes alhora. Cada pas enrere multiplica per $W^\top$, i amb 128 entrades a variància unitària aquest factor té un guany d’aproximadament $\sqrt{128} \approx 11$, que ofega la reducció del $\tanh$ saturat. Els gradients creixen geomètricament en tornar enrere. Això és l’exploding gradient, i produeix valors de pèrdua de nan en pocs passos en qualsevol entrenament real.

La tercera fila és el que vols: activacions amb una escala aproximadament constant al llarg de la profunditat, gradients amb una escala aproximadament constant al llarg de la profunditat. Res no mor, res no explota.

Inicialitzar bé arregla l’escala al pas zero. No la manté fixa: els pesos es mouen, i al pas cinc mil l’argument acurat de la variància ja no s’aplica.

Les capes de normalització imposen l’escala contínuament. Donat un vector d’activacions, resta una mitjana, divideix per una desviació estàndard, i després aplica una escala apresa $\gamma$ i un desplaçament $\beta$ perquè la capa pugui desfer la normalització si resulta que això és el que vol:

L’única pregunta real és sobre què fas la mitjana. Batch normalisation³ pren $\mu$ i $\sigma$ al llarg de la dimensió del batch, una estadística per feature. Layer normalisation⁴ les pren al llarg de les features, una estadística per exemple.

Aquesta tria sembla menor i decideix gairebé tot el que ve després:

Per això LayerNorm és la que tornaràs a veure al capítol 9 sense canvis: el bloc transformer la fa servir, i la fa servir per les raons de la columna de la dreta, no perquè funcioni millor en abstracte.

Quatre possibles arreglos per a la xarxa morta: inicialització Xavier, LayerNorm, connexions residuals i Adam en lloc de SGD. La temptació és aplicar-los tots quatre i continuar. Fes-ho i mai sabràs quin importava, i la pròxima vegada que passi no tindràs cap mètode: només un ritual.

Així que aplica’ls d’un en un. Mateixa seed, mateixes dades, mateixa arquitectura, 800 passos:

Llegeix aquesta taula com la llegiries a les 2 de la matinada i la conclusió és: res no funciona sol, tot funciona conjuntament, per tant el deep learning és alquímia. Aquesta conclusió és equivocada, i descobrir per què és el més útil d’aquest capítol.

Dona a cada execució sis vegades més pressupost —5000 passos en lloc de 800— i canvia completament:

Ara la imatge és nítida, i és un diagnòstic més que no pas un ritual.

La inicialització sola ho arregla. La normalització sola ho arregla. Cadascuna aborda la malaltia real —el senyal cap endavant que col·lapsa fins a zero— i qualsevol de les dues és suficient. Als 800 passos només semblaven mèrit parcial, perquè havien resolt el problema i encara estaven sortint del sot.

Les connexions residuals i Adam no ho arreglen, amb cap pressupost. No perquè siguin dolents, sinó perquè tracten una altra malaltia. Una connexió residual dona al gradient un camí al voltant d’una capa bloquejant; això val molt quan el problema és el gradient, i no val res quan el senyal cap endavant ja és zero, perquè una drecera al voltant d’una capa morta continua portant un valor mort. Adam reescala el pas de cada paràmetre segons el seu propi historial de gradients; això ajuda quan els gradients tenen magnituds molt diferents, i no pot ressuscitar una xarxa la sortida de la qual no depèn de l’entrada.

I «res» continua sent exactament 0.6931 després de cinc mil passos. No 0.6929. No és lenta; és morta, i aquesta distinció ara és visible d’una manera que abans no ho era, perquè tens la fila que diu que un arreglament funciona per comparar-hi.

A partir d’aquí aquest curs fa servir PyTorch. Això s’ha de guanyar més que anunciar, així que aquí tens exactament què fa que tu ja saps fer.

Un optimitzador és una regla per convertir gradients en actualitzacions de paràmetres. El gradient descent simple fa servir el gradient. Momentum en fa servir una mitjana mòbil, cosa que suavitza el soroll i acumula velocitat en direccions que es mantenen consistents:

v = beta * v + p.grad          
p -= lr * v                    

Adam⁵ manté dues mitjanes mòbils —del gradient i del gradient al quadrat— i divideix una per l’arrel quadrada de l’altra, de manera que cada paràmetre rep un pas escalat segons la seva magnitud recent de gradient:

m = b1 * m + (1 - b1) * g          # mean of the gradient          
v = b2 * v + (1 - b2) * g * g      # mean of the squared gradient  
m_hat = m / (1 - b1 ** t)          # bias correction: both averages start at zero
v_hat = v / (1 - b2 ** t)
p -= lr * m_hat / (v_hat.sqrt() + eps)   

Deu línies. Executa tots dos contra torch.optim en el mateix problema durant 50 passos:

SGD+momentum   by hand [2.7781870365142822, -1.0304985046386719]
               torch   [2.7781870365142822, -1.0304983854293823]   max |diff| = 1.19e-07
Adam           by hand [0.4893140196800232, -0.46317872405052185]
               torch   [0.48931416869163513, -0.46317875385284424]   max |diff| = 1.49e-07

Idèntic fins a la precisió float32. torch.optim.Adam són aquestes cinc línies, més dècades de cura amb casos límit i un kernel C++. Aquest és l’intercanvi que fas a partir d’ara: no màgia a canvi d’entendre, sinó velocitat a canvi de línies que ja has escrit.

L’explicació habitual d’Adam és «learning rates adaptatius per paràmetre», que és una descripció més que una raó. La raó és geometria, i es pot mesurar.

Agafa una pèrdua amb curvatura diferent segons la direcció: pronunciada en una, suau en una altra. SGD té un únic learning rate global, així que ha de triar un valor prou petit per ser estable en la direcció més pronunciada; i aquest valor és llavors molt massa petit per a la suau, on el progrés s’arrossega. Això és el que causa la imatge clàssica del gradient descent fent ziga-zaga avall per una vall estreta.

Dues ràtios de curvatura, tres optimitzadors, 300 passos, i cada optimitzador amb el millor learning rate d’un sweep perquè ningú tingui desavantatge:

Amb una ràtio de deu, tot funciona i no hi ha res a discutir. Amb una de mil, l’SGD simple no pot arribar a la resposta amb cap learning rate provat —el seu millor resultat continua sent un error d’1.93— i divergeix directament amb la meitat dels rates. Adam aterra exactament al target i no divergeix amb cap.

Aquesta última columna és la raó pràctica per la qual Adam és el valor per defecte. No és que Adam trobi solucions millors; en problemes ben condicionats, SGD ajustat sovint l’iguala o el supera. És que Adam és molt menys sensible al learning rate que has triat, i les xarxes reals tenen ràtios de curvatura molt pitjors que mil al llarg dels seus milions de paràmetres.

Aquí hi van dues peces més, i totes dues són d’una línia. Gradient clipping reescala el vector de gradient sempre que la seva norma supera un llindar, cosa que converteix la fila «la pèrdua salta de sobte a un valor enorme» de la taula de diagnòstic en un no-esdeveniment. I learning rate schedules: un warmup curt des de gairebé zero durant els primers centenars de passos, perquè les estimacions de variància d’Adam són escombraries fins que han vist alguns gradients i un pas de mida completa pres sobre escombraries pot destrossar una inicialització; després, cosine decay cap a zero, perquè acabar una execució amb la mateixa mida de pas amb què has començat vol dir tremolar al voltant del mínim en lloc d’assentar-s’hi.

Tot fins ara anava d’aconseguir que la pèrdua baixés. Ara ve la meitat més difícil, perquè que la pèrdua baixi no és l’objectiu: és un proxy de l’objectiu, i el proxy falla d’una manera específica i famosa.

Dotze punts d’una funció suau amb una mica de soroll. Ajusta polinomis de grau creixent:

El grau 11 a través de 12 punts passa per tots i cadascun exactament —error d’entrenament zero fins a sis decimals— i és vuit vegades pitjor que el grau 5 en dades que no ha vist. Demana al grau 3 i al grau 11 que prediguin a $x = 3.25$, just fora del rang d’entrenament:

degree  3: predicts   -1.053   (truth -0.012)
degree 11: predicts  +61.224   (truth -0.012)

Seixanta-u, quan la resposta és aproximadament zero. El model no ha après la funció; ha après els dotze punts, i entre ells fa el que l’aritmètica exigeixi.

Això és overfitting, i el seu contrari —grau 1, que no pot representar la corba de cap manera i és dolent a tot arreu— és underfitting. L’explicació clàssica divideix l’error esperat d’un model en tres parts: biaix, l’error perquè el model és massa rígid per representar la veritat; variància, l’error perquè el model és tan flexible que persegueix el soroll d’aquesta mostra concreta; i soroll irreductible, que res no arregla. Els models simples són esbiaixats, els models flexibles tenen variància alta, i la prescripció clàssica és trobar el punt dolç al mig: el grau 5 de la taula anterior.

Les eines estàndard ataquen totes el terme de variància:

• Regularització L2 (weight decay) afegeix $\lambda \lVert w \rVert^2$ a la pèrdua, estirant els pesos cap a zero i fent la funció més suau. A la taula anterior, el coeficient més gran del grau 11 fa el mal; penalitzar la mida el desactiva.
• L1 afegeix $\lambda \sum |w_i|$ en lloc d’això. La diferència no és cosmètica: el gradient de L2 és proporcional al pes i, per tant, es redueix a mesura que ho fa el pes, acostant-se a zero sense arribar-hi, mentre que el gradient de L1 és una constant $\pm\lambda$ que continua empenyent fins al final. Per això L1 produeix pesos que són exactament zero: selecciona features. L2 produeix pesos petits. Fes servir L2 quan vulguis suavitat, L1 quan vulguis esparsitat.
• Dropout⁷ posa a zero un subconjunt aleatori d’activacions a cada pas d’entrenament, de manera que cap unitat pot dependre que cap altra unitat concreta hi sigui present.
• Early stopping observa la pèrdua de validació i s’atura quan gira cap amunt.
• Data augmentation fabrica més exemples d’entrenament a partir dels que tens, cosa que ataca el problema a l’arrel: l’overfitting és tant una manca de dades com un excés de paràmetres.
• Cross-validation divideix les dades de $k$ maneres i entrena $k$ vegades, cosa que compra una estimació fiable de l’error de prova quan tens massa poques dades per reservar un conjunt separat.

Ara ve el fet que trenca la imatge.

La història biaix-variància diu que, passat el punt dolç, més paràmetres volen dir pitjor generalització. Els models de llenguatge moderns tenen molts més paràmetres dels que les regles clàssiques permetrien per a les dades que veuen, i generalitzen magníficament. Totes dues afirmacions són certes, i reconciliar-les és el més útil d’aquest capítol.

Quaranta punts d’entrenament, entrades de vint dimensions, features ReLU aleatòries, i el nombre de features $P$ recorregut de 2 a 5000, amb la solució de norma mínima triada sempre que n’hi ha moltes que encaixen:

Llegeix-ho en tres parts. Fins a $P/n = 0.5$, la història clàssica es compleix exactament: l’error cau i després comença a pujar. A $P = n = 40$ —el llindar d’interpolació, on el model té exactament prou paràmetres per passar per cada punt d’entrenament— l’error de prova arriba al pic, a 5.81, cinc vegades pitjor que el model petit. Aquest pic és l’advertiment clàssic, i és real.

Després torna a baixar. I continua baixant, més enllà de $P = 5n$, més enllà de $P = 37n$, fins a $P = 125n$, on l’error de prova de 0.5664 és millor que el millor model subparametritzat que s’hagi aconseguit. Un model amb 5000 paràmetres ajustat a 40 punts és el millor model de la taula.

Això és doble descens,⁸⁹ i el mecanisme és visible a l’última columna. Un cop $P > n$ hi ha infinites configuracions de paràmetres que encaixen exactament amb les dades d’entrenament, i quina obtens depèn de com tries. La solució de norma mínima tria la més petita, i $\lVert w \rVert$ mostra què vol dir això: arriba al pic de 14.83 just al llindar —on hi ha exactament una solució interpoladora i t’hi quedes atrapat, per extrema que sigui— i després cau monòtonament a mesura que $P$ creix, perquè més paràmetres vol dir més solucions interpoladores per triar, cosa que vol dir que la més petita disponible es fa més petita. A $P = 5000$ la norma és 0.18, vuitanta vegades més petita que al llindar.

Així que els paràmetres extra no afegeixen complexitat. Afegeixen tria, i la regla de selecció gasta aquesta tria en simplicitat. La regularització no és a la funció de pèrdua; és a l’algoritme. Gradient descent des d’una inicialització petita té un biaix documentat cap a solucions de norma petita, i per això aquest comportament apareix en xarxes reals entrenades de la manera ordinària i no només en l’àlgebra lineal anterior.

La conseqüència pràctica, de la qual depèn el capítol 10: «el model té més paràmetres que dades, així que farà overfitting» no és un argument vàlid. Era una bona regla quan els models vivien a l’esquerra del llindar. Ara tot el que és interessant viu molt a la dreta, on la regla s’inverteix.

Les eines d’aquest capítol són suficients per entrenar una xarxa que funcioni amb dades que pots posar en una taula: files de nombres, una columna d’etiquetes.

El llenguatge no és això. Abans que un model pugui predir la paraula següent, alguna cosa ha de decidir què és exactament una «paraula», i la resposta no són ni lletres ni paraules, sinó un vocabulari que el model aprèn dels bytes crus de les dades d’entrenament. Aquesta decisió, presa una vegada abans que comenci l’entrenament, determina quantes coses pot dir el model, quant costa una petició, i per què models que poden aprovar un examen de dret no poden comptar de manera fiable les lletres de strawberry.

El capítol 7 construeix un tokenizer.

Per a les connexions residuals utilitzades més amunt, He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Building makemore Part 3: Activations & Gradients, BatchNorm, d’Andrej Karpathy, recorre el diagnòstic amb histogrames d’activació en un model real i és el millor tractament pràctic de la primera meitat d’aquest capítol. Les lliçons 8 i 11–13 de Learning From Data, de Yaser Abu-Mostafa, expliquen correctament la teoria clàssica de la generalització, incloses les parts que aquest capítol ha comprimit en un paràgraf.