Elérni, hogy tanuljon — és hogy általánosítson

Kezdj azzal, hogy ránézel, nem találgatsz. Küldj át egy batch bemenetet, és írasd ki az aktivációk szórását minden rétegben, majd a súly-gradientek szórását:

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}")

Három initialisation, ugyanaz az architektúra, hat rétegnyi $\tanh$:

Az első sor a fenti hálózat, és nem lassan tanul — már nem maradt benne jel. A negyedik rétegre az aktiváció szórása négy tizedesjegyen nullára alulcsordul. Minden bemenet ugyanazt a kimenetet állítja elő, a kimenet konstans, egy konstans gradientje pedig semmi. A súlyokat kicsire initializáltuk, „a biztonság kedvéért”, és a kicsi végzetes volt.

A második sor az ellenkező hiba, és érdemes megérteni, mert ellentmond az intuíciónak. Az aktivációk egészségesnek tűnnek — körülbelül 0.96 —, de ez $\tanh$ telített állapota, a határához szegezve, pontosan az a tartomány, amelyről az 5. fejezet kimérte, hogy majdnem tízezres gradientvesztést okoz. És mégis óriásiak a gradientek: 1940 az első rétegben. Mindkettő egyszerre igaz. Minden backward lépés szoroz $W^\top$ értékével, és 128 egységvarianciájú bemenetnél ennek a tényezőnek körülbelül $\sqrt{128} \approx 11$ erősítése van, ami elnyomja a telített $\tanh$ zsugorító hatását. A gradientek geometrikusan nőnek visszafelé haladva. Ez az exploding gradient, és bármely valós tanítási futásban néhány lépésen belül nan loss értékeket eredményez.

A harmadik sor az, amit szeretnél: az aktivációk skálája nagyjából állandó marad a mélységen át, a gradientek skálája nagyjából állandó marad a mélységen át. Semmi nem hal el, semmi nem robban fel.

A jó initialisation a nulladik lépésben rendbe teszi a skálát. De nem tartja rendben: a súlyok mozognak, és az ötezredik lépésre a gondos varianciaérv már nem érvényes.

A normalizációs rétegek folyamatosan kikényszerítik a skálát. Egy aktivációvektorból vonj ki egy átlagot, oszd el egy szórással, majd alkalmazz egy tanult skálát $\gamma$ és eltolást $\beta$, hogy a réteg vissza tudja vonni a normalizációt, ha végül ez bizonyul annak, amit szeretne:

Az egyetlen valódi kérdés az, hogy mi felett átlagolsz. A batch normalizáció³ a $\mu$ és $\sigma$ értékeket a batch dimenzión veszi, feature-önként egy statisztikával. A layer normalizáció⁴ ugyanezeket a feature-ök felett veszi, példányonként egy statisztikával.

Ez a választás aprónak tűnik, és szinte mindent eldönt később:

Ezért a LayerNorm az, amellyel a 9. fejezetben változatlanul találkozol újra: a transformer blokk ezt használja, és a jobb oldali oszlopban szereplő okok miatt használja, nem azért, mert absztrakt értelemben jobban működik.

Négy lehetséges javítás a halott hálózatra: Xavier initialisation, LayerNorm, residual connectionök és Adam SGD helyett. A kísértés az, hogy mind a négyet alkalmazd, és lépj tovább. Ha ezt teszed, soha nem fogod tudni, melyik számított, és amikor legközelebb megtörténik, nem lesz módszered — csak rituáléd.

Ezért alkalmazd őket egyenként. Ugyanaz a seed, ugyanaz az adat, ugyanaz az architektúra, 800 lépés:

Olvasd ezt a táblát úgy, ahogy hajnali kettőkor olvasnád, és a következtetés ez: önmagában semmi nem működik, együtt minden működik, tehát a deep learning alkímia. Ez a következtetés téves, és kideríteni, miért, ennek a fejezetnek a leghasznosabb része.

Adj minden futásnak hatszor akkora keretet — 800 helyett 5000 lépést —, és a kép teljesen megváltozik:

Most a kép éles, és ez diagnózis, nem rituálé.

Az initialisation önmagában megjavítja. A normalizáció önmagában megjavítja. Mindkettő a valódi betegséget kezeli — a forward jel nullára omlását —, és bármelyik elég. 800 lépésnél csak részleges sikernek látszottak, mert már megoldották a problémát, csak még kifelé másztak belőle.

A residual connectionök és az Adam semmilyen keret mellett nem javítják meg. Nem azért, mert rosszak, hanem mert más betegséget kezelnek. Egy residual connection utat ad a gradientnek egy blokkoló réteg körül; ez nagyon sokat ér, amikor a gradient a probléma, és semmit nem ér, amikor a forward jel már nulla, mert egy halott réteg körüli rövidítés is halott értéket visz. Az Adam minden paraméter lépését a saját gradienttörténete alapján skálázza; ez akkor segít, ha a gradientek nagyságrendje vadul eltér, de nem tud feltámasztani egy olyan hálózatot, amelynek kimenete nem függ a bemenetétől.

És a „semmi” öt ezer lépés után is pontosan 0.6931. Nem 0.6929. Nem lassú; halott, és ez a különbség most már látható, ahogy korábban nem volt az, mert van egy sorod, amelyhez képest látod, hogy egy javítás működik.

Innentől ez a kurzus PyTorchot használ. Ezt érdemes kiérdemelni, nem csak bejelenteni, ezért itt van pontosan, mit csinál abból, amit már te is tudsz.

Egy optimalizáló olyan szabály, amely a gradientekből paraméterfrissítéseket csinál. A sima gradient descent a gradientet használja. A Momentum ennek futóátlagát használja, ami kisimítja a zajt, és sebességet épít azokban az irányokban, amelyek következetesek maradnak:

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

Az Adam⁵ két futóátlagot tart fenn — a gradientét és a gradient négyzetéét —, és az egyiket elosztja a másik négyzetgyökével, így minden paraméter a saját közelmúltbeli gradientnagyságához skálázott lépést kap:

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)   

Tíz sor. Futtasd mindkettőt torch.optim ellen ugyanazon a problémán 50 lépésig:

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

Float32 pontosságig azonos. A torch.optim.Adam ez az öt sor, plusz évtizedek gondoskodása peremesetekről és egy C++ kernel. Innentől ezt a cserét kötöd: nem mágia a megértésért, hanem sebesség azokért a sorokért, amelyeket már megírtál.

Az Adam szokásos magyarázata az, hogy „adaptív paraméterenkénti learning rate-ek”, ami inkább leírás, mint ok. Az ok a geometria, és mérhető.

Vegyél egy loss-t, amelynek görbülete irányonként eltér: az egyikben meredek, a másikban lapos. Az SGD-nek egy globális learning rate-je van, ezért olyan értéket kell választania, amely elég kicsi ahhoz, hogy a legmeredekebb irányban stabil legyen — ez az érték pedig túl kicsi lesz a lapos irányhoz, ahol a haladás vánszorog. Ez okozza a gradient descent klasszikus képét, ahogy egy keskeny völgyben cikcakkban halad lefelé.

Két görbületi arány, három optimalizáló, 300 lépés, és minden optimalizáló a sweepből kapott legjobb learning rate-et kapja, hogy senki ne induljon hátrányból:

Tízes aránynál minden működik, nincs miről beszélni. Ezernél a sima SGD egyetlen kipróbált learning rate mellett sem éri el a választ — a legjobb eredménye még mindig 1.93 hiba —, és a ráták felénél egyenesen divergál. Az Adam pontosan a célra érkezik, és egyiknél sem divergál.

Ez az utolsó oszlop az a gyakorlati ok, amiért az Adam az alapértelmezett. Nem arról van szó, hogy az Adam jobb megoldásokat talál; jól kondicionált problémákon a hangolt SGD gyakran utoléri vagy meg is veri. Hanem arról, hogy az Adam sokkal kevésbé érzékeny a választott learning rate-re, a valós hálózatokban pedig a görbületi arányok a paramétermilliókon át ezernél sokkal rosszabbak.

Két további elem tartozik ide, és mindkettő egy sor. A gradient clipping újraskálázza a gradientvektort, amikor a normája meghalad egy küszöböt, így a diagnosztikai tábla „a loss hirtelen hatalmas értékre ugrik” sora nem eseménnyé válik. És a learning rate schedule-ök: egy rövid warmup közel nulláról az első néhány száz lépés alatt, mert az Adam varianciabecslései szemét értékek, amíg nem láttak néhány gradientet, és egy teljes méretű lépés szemét alapján tönkretehet egy initialisationt; majd cosine decay nulla felé, mert ha a futást ugyanazzal a lépésmérettel zárod, amellyel kezdted, akkor a minimum körül remegsz, nem pedig belenyugszol.

Eddig minden arról szólt, hogyan csökkentsük a loss-t. Most jön a nehezebb fele, mert a loss csökkenése nem a cél — csak helyettesítője a célnak, és ez a helyettesítő egy konkrét és híres módon elromlik.

Tizenkét pont egy sima függvényből, egy kis zajjal. Illessz növekvő fokszámú polinomokat:

A 11. fokú polinom 12 ponton át mindegyiken pontosan áthalad — train hiba hat tizedesjegyig nulla —, és nyolcszor rosszabb az 5. fokúnál olyan adaton, amelyet nem látott. Kérd meg a 3. és a 11. fokú modellt, hogy jósoljon $x = 3.25$ pontban, közvetlenül a tanítási tartományon kívül:

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

Hatvanegy, miközben a válasz körülbelül nulla. A modell nem a függvényt tanulta meg; a tizenkét pontot tanulta meg, és közöttük azt csinálja, amit az aritmetika megkövetel.

Ez az overfitting, az ellentéte pedig — az 1. fok, amely egyáltalán nem tudja reprezentálni a görbét, és mindenhol rossz — az underfitting. A klasszikus magyarázat a modell várható hibáját három részre bontja: bias, az a hiba, amely abból ered, hogy a modell túl merev az igazság reprezentálásához; variance, az a hiba, amely abból ered, hogy a modell annyira rugalmas, hogy ebben a konkrét mintában a zajt üldözi; és irreducibilis zaj, amelyet semmi nem javít. Az egyszerű modellek biasosak, a rugalmas modellek nagy variance-űek, és a klasszikus recept az, hogy találd meg a középutat — a fenti táblában az 5. fokot.

A standard eszközök mind a variance tagot támadják:

• L2 regularizáció (weight decay) $\lambda \lVert w \rVert^2$ tagot ad a loss-hoz, nullához húzza a súlyokat, és simábbá teszi a függvényt. A fenti táblában a 11. fok legnagyobb együtthatója okozza a kárt; a méret büntetése hatástalanítja.
• L1 ehelyett $\lambda \sum |w_i|$ tagot ad hozzá. A különbség nem kozmetikai: az L2 gradientje arányos a súllyal, ezért a súllyal együtt zsugorodik, közelít nullához anélkül, hogy odaérne, míg az L1 gradientje konstans $\pm\lambda$, amely végig tol tovább. Az L1 ezért pontosan nulla súlyokat hoz létre — feature-öket választ. Az L2 kis súlyokat hoz létre. Használd az L2-t, ha simaságot akarsz, és az L1-et, ha ritkaságot.
• A Dropout⁷ minden tanítási lépésben az aktivációk véletlen részhalmazát nullázza, így egyetlen egység sem támaszkodhat arra, hogy bármely másik konkrét egység jelen lesz.
• Az Early stopping figyeli a validation loss-t, és megáll, amikor az felfelé fordul.
• A Data augmentation további tanító példákat gyárt a meglévőkből, ami a forrásánál támadja a problémát: az overfitting éppúgy adathiány, mint paramétertöbblet.
• A Cross-validation $k$ részre osztja az adatot, és $k$ alkalommal tanít, ami megbízható becslést ad a test hibára, amikor túl kevés az adat ahhoz, hogy külön held-out készletet félretegyél.

Most jön a tény, amely megtöri a képet.

A bias-variance történet azt mondja, hogy az édes pont után több paraméter rosszabb általánosítást jelent. A modern nyelvi modelleknek sokkal több paraméterük van, mint amit a klasszikus szabályok az általuk látott adathoz megengednének, és kiválóan általánosítanak. Mindkét állítás igaz, és összeegyeztetni őket ennek a fejezetnek a leghasznosabb része.

Negyven tanítási pont, húszdimenziós bemenetek, véletlen ReLU feature-ök, és a feature-ök száma $P$ 2-től 5000-ig végigsöpörve — a minimum-norm megoldást választva, amikor sok olyan van, amely illeszkedik:

Olvasd három részben. $P/n = 0.5$ értékig a klasszikus történet pontosan érvényes: a hiba csökken, majd emelkedni kezd. $P = n = 40$ értéknél — az interpolációs küszöbnél, ahol a modellnek pontosan elég paramétere van ahhoz, hogy minden tanítási ponton átmenjen — a test hiba csúcsra ér, 5.81-nél, ötször rosszabbul, mint a kis modell. Ez a csúcs a klasszikus figyelmeztetés, és valós.

Aztán újra ereszkedik. És tovább ereszkedik, túl $P = 5n$ értéken, túl $P = 37n$ értéken, egészen $P = 125n$ értékig, ahol a 0.5664-es test hiba jobb, mint amit a legjobb alulparaméterezett modell valaha elért. A táblában a legjobb modell az, amelynek 5000 paraméterét 40 pontra illesztettük.

Ez a double descent,⁸⁹ és a mechanizmus látható az utolsó oszlopban. Amint $P > n$, végtelen sok paraméterbeállítás illeszkedik pontosan a tanítási adatra, és hogy melyiket kapod, attól függ, hogyan választasz. A minimum-norm megoldás a legkisebbet választja, és $\lVert w \rVert$ megmutatja, ez mit jelent: közvetlenül a küszöbnél 14.83-on tetőzik — ahol pontosan egy interpoláló megoldás van, és azzal kell beérned, bármilyen szélsőséges —, majd monoton csökken, ahogy $P$ nő, mert a több paraméter több választható interpoláló megoldást jelent, vagyis a legkisebb elérhető is kisebb lesz. $P = 5000$ értéknél a norm 0.18, nyolcvanszor kisebb, mint a küszöbnél.

Tehát az extra paraméterek nem komplexitást adnak hozzá. Választási lehetőséget adnak hozzá, és a kiválasztási szabály ezt a választási lehetőséget egyszerűségre költi. A regularizáció nincs a loss függvényben; az algoritmusban van. A gradient descent kis initialisationből dokumentáltan a kis normájú megoldások felé biasol, ezért jelenik meg ez a viselkedés a szokásos módon tanított valós hálózatokban is, nem csak a fenti lineáris algebrában.

A gyakorlati következmény, amelyre a 10. fejezet épít: „a modellnek több paramétere van, mint amennyi adat, tehát overfitelni fog” nem érvényes érv. Jó szabály volt, amikor a modellek a küszöb bal oldalán éltek. Most minden érdekes dolog messze a jobb oldalán él, ahol a szabály megfordul.

A fejezet eszközei elegendők ahhoz, hogy olyan hálózatot taníts, amely működik táblázatba tehető adatokon: számsorokon és egy címkeoszlopon.

A nyelv nem ilyen. Mielőtt egy modell meg tudná jósolni a következő szót, valaminek el kell döntenie, mi is egyáltalán a „szó” — és a válasz sem nem betűk, sem nem szavak, hanem egy szókészlet, amelyet a modell a tanítási adatok nyers byte-jaiból tanul meg. Ez a döntés, amely egyszer, a tanítás megkezdése előtt születik, meghatározza, hány dolgot tud a modell kimondani, mennyibe kerül egy kérés, és miért nem tudják a jogi vizsgán átmenő modellek megbízhatóan megszámolni a strawberry betűit.

A 7. fejezet tokenizer-t épít.

A fent használt residual connectionökhöz: He és mtsai., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathy Building makemore Part 3: Activations & Gradients, BatchNorm című anyaga végigvezeti az aktivációhisztogram-diagnosztikát egy valós modellen, és ennek a fejezetnek az első feléhez a legjobb gyakorlati feldolgozás. Yaser Abu-Mostafa Learning From Data előadásai közül a 8. és a 11–13. rész adja meg rendesen a klasszikus általánosításelméletet, beleértve azokat a részeket is, amelyeket ez a fejezet egy bekezdésbe sűrített.