Miten saada se oppimaan ja yleistämään

Aloita katsomalla arvaamisen sijaan. Syötä batch syötteitä verkon läpi ja tulosta aktivaatioiden keskihajonta jokaisessa kerroksessa, ja sitten painogradienttien keskihajonta:

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

Kolme initialisointia, sama arkkitehtuuri, kuusi kerrosta $\tanh$:

Ensimmäinen rivi on yllä oleva verkko, eikä se opi hitaasti — sillä ei ole signaalia jäljellä. Neljänteen kerrokseen mennessä aktivaatioiden keskihajonta on alivuotanut nollaan neljän desimaalin tarkkuudella. Jokainen syöte tuottaa saman ulostulon, ulostulo on vakio, ja vakion gradientti ei ole mitään. Painot initialisoitiin pieniksi "varmuuden vuoksi", ja pieni oli kohtalokasta.

Toinen rivi on vastakkainen epäonnistuminen, ja se kannattaa ymmärtää, koska se on epäintuitiivinen. Aktivaatiot näyttävät terveiltä — noin 0.96 — mutta se on $\tanh$ saturoituneena, kiinni lähellä rajaansa, juuri siinä tilassa, jonka luvussa 5 mitattiin menettävän gradientista lähes kymmenentuhannen kertoimen. Ja silti gradientit ovat valtavia: 1940 ensimmäisessä kerroksessa. Molemmat ovat totta yhtä aikaa. Jokainen taaksepäin kulkeva askel kertoo luvulla $W^\top$, ja 128 syötteellä yksikkövarianssissa tuon tekijän vahvistus on noin $\sqrt{128} \approx 11$, mikä peittää saturoituneesta $\tanh$:sta tulevan kutistumisen. Gradientit kasvavat geometrisesti paluumatkalla. Tämä on exploding gradient, ja se tuottaa nan-loss-arvoja muutamassa askeleessa missä tahansa todellisessa koulutusajossa.

Kolmas rivi on se, mitä haluat: aktivaatiot pysyvät suunnilleen samassa mittakaavassa syvyyden yli, gradientit pysyvät suunnilleen samassa mittakaavassa syvyyden yli. Mikään ei kuole, mikään ei räjähdä.

Hyvä initialisointi korjaa mittakaavan askeleessa nolla. Se ei pidä sitä korjattuna: painot liikkuvat, ja askeleeseen viisi tuhatta mennessä huolellinen varianssiargumentti ei enää päde.

Normalisointikerrokset pakottavat mittakaavan jatkuvasti. Kun annetaan aktivaatioiden vektori, vähennä keskiarvo, jaa keskihajonnalla, ja sovella sitten opittua skaalaa $\gamma$ ja siirtoa $\beta$, jotta kerros voi kumota normalisoinnin, jos se osoittautuu sen haluamaksi:

Ainoa todellinen kysymys on minkä yli keskiarvoistat. Batch normalisation³ ottaa $\mu$ ja $\sigma$ batch-ulottuvuuden yli, yksi tilasto per piirre. Layer normalisation⁴ ottaa ne piirteiden yli, yksi tilasto per esimerkki.

Tuo valinta näyttää pieneltä ja ratkaisee lähes kaiken myöhemmin:

Siksi LayerNorm on se, jonka kohtaat uudelleen luvussa 9 muuttumattomana: transformer-lohko käyttää sitä, ja se käyttää sitä oikeanpuoleisen sarakkeen syistä, ei siksi, että se toimisi abstraktisti paremmin.

Neljä ehdokaskorjausta kuolleelle verkolle: Xavier-initialisointi, LayerNorm, residuaaliyhteydet ja Adam SGD:n sijaan. Houkutus on käyttää kaikkia neljää ja jatkaa eteenpäin. Tee niin, etkä koskaan tiedä, millä oli merkitystä, ja seuraavalla kerralla sinulla ei ole menetelmää — vain rituaali.

Käytä niitä siis yksi kerrallaan. Sama seed, sama data, sama arkkitehtuuri, 800 askelta:

Lue tuota taulukkoa niin kuin lukisit sitä kello 2 yöllä, ja johtopäätös on: mikään ei toimi yksin, kaikki toimii yhdessä, joten deep learning on alkemiaa. Tuo johtopäätös on väärä, ja sen selvittäminen miksi on tämän luvun hyödyllisin asia.

Anna jokaiselle ajolle kuusinkertainen budjetti — 5000 askelta 800:n sijaan — ja kuva muuttuu täysin:

Nyt kuva on terävä, ja kyse on diagnoosista eikä rituaalista.

Initialisointi yksin korjaa sen. Normalisointi yksin korjaa sen. Kumpikin osuu varsinaiseen sairauteen — forward-signaalin romahtamiseen nollaan — ja kumpi tahansa riittää. 800 askeleessa ne vain näyttivät osittaisilta pisteiltä, koska ne olivat ratkaisseet ongelman mutta olivat vielä kiipeämässä ulos.

Residuaaliyhteydet ja Adam eivät korjaa sitä millään budjetilla. Eivät siksi, että ne olisivat huonoja, vaan koska ne hoitavat eri sairautta. Residuaaliyhteys antaa gradientille reitin estävän kerroksen ympäri; se on valtavan arvokasta, kun ongelma on gradientissa, eikä yhtään arvokasta, kun forward-signaali on jo nolla, koska oikoreitti kuolleen kerroksen ympäri kantaa silti kuollutta arvoa. Adam skaalaa jokaisen parametrin askeleen sen oman gradienttihistorian mukaan; se auttaa, kun gradienttien suuruudet ovat villisti erilaisia, eikä se voi herättää henkiin verkkoa, jonka ulostulo ei riipu sen syötteestä.

Ja "ei mitään" on yhä täsmälleen 0.6931 viiden tuhannen askeleen jälkeen. Ei 0.6929. Se ei ole hidas; se on kuollut, ja tuo ero näkyy tavalla, jota se ei ennen näkynyt, koska sinulla on vertailukohtana rivi, joka sanoo korjauksen toimivan.

Tästä eteenpäin tämä kurssi käyttää PyTorchia. Se pitäisi ansaita eikä vain ilmoittaa, joten tässä on täsmälleen, mitä se tekee sellaista, minkä osaat jo tehdä.

Optimointialgoritmi on sääntö gradienttien muuttamiseksi parametripäivityksiksi. Tavallinen gradient descent käyttää gradienttia. Momentum käyttää sen juoksevaa keskiarvoa, mikä tasoittaa kohinaa ja rakentaa vauhtia suuntiin, jotka pysyvät johdonmukaisina:

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

Adam⁵ pitää kahta juoksevaa keskiarvoa — gradientista ja gradientin neliöstä — ja jakaa toisen toisen neliöjuurella, jotta jokainen parametri saa askeleen, joka on skaalattu sen oman viimeaikaisen gradienttisuuruuden mukaan:

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)   

Kymmenen riviä. Aja molemmat torch.optim:ta vastaan samassa ongelmassa 50 askelta:

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

Identtisiä float32-tarkkuuteen asti. torch.optim.Adam on nuo viisi riviä, plus vuosikymmenten huolenpito reunatapauksista ja C++-kerneli. Se on kauppa, jonka teet tästä eteenpäin: ei taikaa ymmärryksen tilalle, vaan nopeutta riveille, jotka olet jo kirjoittanut.

Tavallinen selitys Adamille on "adaptiiviset parametrikohtaiset learning rate -arvot", mikä on kuvaus eikä syy. Syy on geometria, ja se voidaan mitata.

Ota loss, jonka kaarevuus eroaa suunnittain: jyrkkä yhdessä, loiva toisessa. SGD:llä on yksi globaali learning rate, joten sen täytyy valita arvo, joka on tarpeeksi pieni ollakseen vakaa jyrkimmässä suunnassa — ja tuo arvo on sitten aivan liian pieni loivassa suunnassa, jossa eteneminen matelee. Tästä syntyy klassinen kuva gradient descentistä siksakkaamassa alas kapeaa laaksoa.

Kaksi kaarevuussuhdetta, kolme optimointialgoritmia, 300 askelta, ja jokaiselle optimointialgoritmille annettu paras learning rate sweepistä, jotta ketään ei haitata:

Suhteella kymmenen kaikki toimii eikä ole mitään keskusteltavaa. Suhteella tuhat tavallinen SGD ei pääse vastaukseen millään kokeillulla learning rate -arvolla — sen paras tulos on yhä virhe 1.93 — ja se divergoi suoraan puolilla arvoista. Adam osuu täsmälleen targetiin eikä divergoi millään niistä.

Tuo viimeinen sarake on käytännön syy, miksi Adam on oletus. Kyse ei ole siitä, että Adam löytäisi parempia ratkaisuja; hyvin ehdollistetuissa ongelmissa viritetty SGD usein vastaa sitä tai päihittää sen. Kyse on siitä, että Adam on paljon vähemmän herkkä valitsemallesi learning rate -arvolle, ja todellisissa verkoissa kaarevuussuhteet ovat paljon pahempia kuin tuhat niiden miljoonien parametrien yli.

Kaksi muuta palaa kuuluu tähän, ja molemmat ovat yhden rivin asioita. Gradient clipping skaalaa gradienttivektorin uudelleen aina, kun sen normi ylittää kynnyksen, mikä muuttaa diagnostiikkataulukon rivin "loss hyppää yhtäkkiä valtavaan arvoon" ei-tapahtumaksi. Ja learning rate schedule: lyhyt warmup lähes nollasta ensimmäisten muutaman sadan askeleen aikana, koska Adamin varianssiestimaatit ovat roskaa, kunnes ne ovat nähneet gradientteja, ja roskan perusteella otettu täysikokoinen askel voi tuhota initialisoinnin; sitten cosine decay kohti nollaa, koska ajon lopettaminen samalla askelkoolla kuin aloitit tarkoittaa värähtelyä minimin ympärillä siihen asettumisen sijaan.

Kaikki tähän asti koski lossin saamista alas. Nyt tulee vaikeampi puolikas, koska lossin laskeminen ei ole tavoite — se on sijaismittari tavoitteelle, ja sijaismittari epäonnistuu tietyllä kuuluisalla tavalla.

Kaksitoista pistettä sileästä funktiosta, jossa on vähän kohinaa. Sovita kasvavan asteen polynomeja:

Aste 11 kahdentoista pisteen läpi kulkee jokaisesta täsmälleen — train-virhe nolla kuuden desimaalin tarkkuudella — ja on kahdeksan kertaa huonompi kuin aste 5 datalla, jota se ei ole nähnyt. Pyydä astetta 3 ja astetta 11 ennustamaan kohdassa $x = 3.25$, juuri koulutusalueen ulkopuolella:

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

Kuusikymmentäyksi, kun vastaus on suunnilleen nolla. Malli ei oppinut funktiota; se oppi ne kaksitoista pistettä, ja niiden välissä se tekee mitä aritmetiikka vaatii.

Tämä on overfitting, ja sen vastakohta — aste 1, joka ei pysty esittämään käyrää lainkaan ja on huono kaikkialla — on underfitting. Klassinen selitys jakaa mallin odotetun virheen kolmeen osaan: bias, virhe siitä, että malli on liian jäykkä esittämään totuutta; variance, virhe siitä, että malli on niin joustava, että se jahtaa juuri tämän otoksen kohinaa; ja redusoitumaton kohina, jota mikään ei korjaa. Yksinkertaiset mallit ovat biased, joustavat mallit ovat korkean variance-arvon malleja, ja klassinen resepti on löytää keskeltä sweet spot — aste 5 yllä olevassa taulukossa.

Vakiotyökalut hyökkäävät kaikki variance-termiä vastaan:

• L2-regularisointi (weight decay) lisää $\lambda \lVert w \rVert^2$ lossiin, vetäen painoja kohti nollaa ja tehden funktiosta sileämmän. Yllä olevassa taulukossa asteen 11 suurin kerroin tekee vahingon; koon rankaiseminen purkaa sen.
• L1 lisää sen sijaan $\lambda \sum |w_i|$. Ero ei ole kosmeettinen: L2:n gradientti on verrannollinen painoon ja siis pienenee painon pienetessä, lähestyen nollaa saapumatta siihen, kun taas L1:n gradientti on vakio $\pm\lambda$, joka jatkaa työntämistä loppuun asti. L1 tuottaa siksi painoja, jotka ovat täsmälleen nolla — se valitsee piirteitä. L2 tuottaa pieniä painoja. Käytä L2:ta, kun haluat sileyttä, L1:tä, kun haluat harvuutta.
• Dropout⁷ nollaa satunnaisen osajoukon aktivaatioista jokaisella koulutusaskeleella, joten yksikään yksikkö ei voi luottaa siihen, että mikään tietty toinen yksikkö on läsnä.
• Early stopping seuraa validation lossia ja pysäyttää, kun se kääntyy ylöspäin.
• Data augmentation valmistaa lisää koulutusesimerkkejä niistä, joita sinulla on, mikä hyökkää ongelman juureen: overfitting on yhtä paljon datan puutetta kuin parametrien ylimäärää.
• Cross-validation jakaa datan $k$ tavalla ja kouluttaa $k$ kertaa, mikä ostaa luotettavan arvion testivirheestä, kun dataa on liian vähän erillisen hold-out-joukon säästämiseen.

Nyt tulee fakta, joka rikkoo kuvan.

Bias-variance-tarina sanoo, että sweet spotin jälkeen useammat parametrit tarkoittavat huonompaa yleistämistä. Moderneissa language modeleissa on paljon enemmän parametreja kuin klassiset säännöt sallisivat niiden näkemälle datalle, ja ne yleistyvät erinomaisesti. Molemmat väitteet ovat totta, ja niiden sovittaminen yhteen on tämän luvun hyödyllisin asia.

Neljäkymmentä koulutuspistettä, kaksikymmentäulotteiset syötteet, satunnaiset ReLU-piirteet, ja piirteiden määrä $P$ sweepattuna 2:sta 5000:een — niin, että miniminorminen ratkaisu valitaan aina, kun sopivia ratkaisuja on monta:

Lue se kolmessa osassa. Arvoon $P/n = 0.5$ asti klassinen tarina pätee täsmälleen: virhe laskee ja alkaa sitten nousta. Kohdassa $P = n = 40$ — interpolaatiokynnyksellä, jossa mallilla on täsmälleen tarpeeksi parametreja kulkeakseen jokaisen koulutuspisteen läpi — testivirhe saavuttaa huipun, 5.81, viisi kertaa huonompi kuin pieni malli. Tuo huippu on klassinen varoitus, ja se on todellinen.

Sitten se laskee uudelleen. Ja jatkaa laskemista, ohi kohdan $P = 5n$, ohi kohdan $P = 37n$, aina kohtaan $P = 125n$ asti, jossa testivirhe 0.5664 on parempi kuin paras alparametrisoitu malli koskaan saavutti. Malli, jossa on 5000 parametria sovitettuna 40 pisteeseen, on taulukon paras malli.

Tämä on double descent,⁸⁹ ja mekanismi näkyy viimeisessä sarakkeessa. Kun $P > n$, on äärettömän monta parametriasetusta, jotka sopivat koulutusdataan täsmälleen, ja se, minkä saat, riippuu siitä, miten valitset. Miniminorminen ratkaisu valitsee pienimmän, ja $\lVert w \rVert$ näyttää, mitä se tarkoittaa: se huipentuu arvoon 14.83 juuri kynnyksellä — jossa on täsmälleen yksi interpoloiva ratkaisu ja olet jumissa sen kanssa, kuinka äärimmäinen se sitten onkin — ja sitten laskee monotonisesti, kun $P$ kasvaa, koska useammat parametrit tarkoittavat enemmän interpoloivia ratkaisuja, joista valita, mikä tarkoittaa, että pienin saatavilla oleva pienenee. Kohdassa $P = 5000$ normi on 0.18, kahdeksankymmentä kertaa pienempi kuin kynnyksellä.

Lisäparametrit eivät siis lisää monimutkaisuutta. Ne lisäävät valinnanvaraa, ja valintasääntö käyttää tuon valinnanvaran yksinkertaisuuteen. Regularisointi ei ole loss-funktiossa; se on algoritmissa. gradient descent pienestä initialisoinnista on dokumentoidusti biased kohti pienen normin ratkaisuja, minkä vuoksi tämä käyttäytyminen näkyy tavalliseen tapaan koulutetuissa todellisissa verkoissa eikä vain yllä olevassa lineaarialgebrassa.

Käytännön seuraus, josta luku 10 riippuu: "mallilla on enemmän parametreja kuin dataa, joten se overfittaa" ei ole pätevä argumentti. Se oli hyvä sääntö, kun mallit elivät kynnyksen vasemmalla puolella. Kaikki kiinnostava elää nyt kaukana sen oikealla puolella, missä sääntö kääntyy.

Tämän luvun työkalut riittävät kouluttamaan verkon, joka toimii datalla, jonka voit laittaa taulukkoon: numerorivejä ja label-sarake.

Kieli ei ole sitä. Ennen kuin malli voi ennustaa seuraavan sanan, jonkin täytyy päättää, mikä "sana" edes on — eikä vastaus ole kirjaimet eikä sanat, vaan sanasto, jonka malli oppii koulutusdatan raaoista tavuista. Tuo päätös, joka tehdään kerran ennen koulutuksen alkua, määrittää, kuinka monta asiaa malli voi sanoa, paljonko pyyntö maksaa, ja miksi mallit, jotka voivat läpäistä oikeustieteen kokeen, eivät osaa luotettavasti laskea kirjaimia sanassa strawberry.

Luku 7 rakentaa tokenizerin.

Yllä käytetyistä residuaaliyhteyksistä: He et al., Deep Residual Learning for Image Recognition (arXiv:1512.03385). Andrej Karpathyn Building makemore Part 3: Activations & Gradients, BatchNorm käy läpi aktivaatiohistogrammien diagnostiikan todellisella mallilla ja on tämän luvun ensimmäisen puolikkaan paras käytännönläheinen käsittely. Yaser Abu-Mostafan Learning From Data -luentojen 8 ja 11–13 kautta saa klassisen yleistämisteorian kunnolla, mukaan lukien ne osat, jotka tämä luku tiivisti yhteen kappaleeseen.