Next-token prediction: Embeddings, og hvad perplexity betyder

Kapitel 7 efterlod dig med en sekvens af heltal og ingen grund til, at ét skulle følge efter et andet. Her er grunden, og den er én linje fra kapitel 2.

En sprogmodel er en funktion, der tager de hidtidige tokens og returnerer en distribution over, hvilken token der kommer næste gang: ét tal per opslag i vocabulary, ikke-negativt, og summerende til én. Intet andet. For at komme derfra til en sandsynlighed for et helt dokument skal du anvende sandsynlighedens kæderegel:

Det er en identitet, sand for enhver sekvens af hvad som helst, uden antagelser knyttet til den. Så en model, der løser den lille opgave — næste token givet de foregående — har allerede løst den store opgave med at tildele en sandsynlighed til ethvert muligt dokument, præcist og gratis. Den populære framing af dette som et billigt trick ("den forudsiger jo kun det næste ord") vender logikken på hovedet: At forudsige næste token er at modellere den fælles distribution. Der var aldrig en anden ting at gøre.

Loss følger lige så mekanisk. Ved hver position producerer modellen en distribution $q$, og sandheden er én kendt token, så cross-entropy fra kapitel 4 gælder uændret:

Det er den gennemsnitlige negative log-likelihood — opskriften fra kapitel 2 med en kategorisk distribution i det slot, hvor Gauss-fordelingen sad. Og eftersom den sande distribution er one-hot, er dens entropi nul, så ifølge identiteten fra kapitel 4 er cross-entropy lig med KL-divergensen: At drive dette tal ned og trække modellens overbevisninger mod dataenes er samme handling.

Én konsekvens fortjener sin egen sætning, fordi den er den økonomiske kendsgerning under hele feltet. Labels er dataene, forskudt én position. Ingen annoterer noget. En billion tokens tekst er en billion præ-labellede eksempler, og derfor er træningskorpuset for en moderne model "internettet" og ikke "et dataset, nogen byggede".

Før noget netværk, baseline: 32.033 navne, ét per linje, og opgaven er at producere flere af dem ét bogstav ad gangen.¹

Vocabulary er 26 bogstaver plus et grænsesymbol ., der markerer både starten og slutningen på et navn, så modellen skal lære, hvor navne begynder, og hvor de stopper. Det er 27 symboler, og den mindst mulige model er en tabel over, hvor ofte hvert symbol fulgte efter hvert andet symbol.

N = torch.zeros((27, 27), dtype=torch.int32)
for w in words:
    cs = ["."] + list(w) + ["."]
    for a, b in zip(cs, cs[1:]):
        N[stoi[a], stoi[b]] += 1

P = N.float()
P = P / P.sum(1, keepdim=True)            # one distribution per row   

To linjers aritmetik, og modellen er fitted — og det er ikke en heuristik: At dividere counts med rækketotaler er maximum-likelihood-estimatet for en kategorisk distribution, som er opskriften fra kapitel 2 med differentialregningen allerede udført.

names: 32033        train/val/test: 25626 / 3203 / 3204
training bigrams: 182583

the six most likely letters after 'a':
    a -> '.'  0.1944   a -> 'n'  0.1600   a -> 'r'  0.0967
    a -> 'l'  0.0749   a -> 'h'  0.0690   a -> 'y'  0.0606

Sample fra den — vælg et bogstav fra rækken for det aktuelle bogstav, flyt til den række, gentag indtil grænsesymbolet dukker op — og du får navnene øverst i dette kapitel. De fejler på en specifik og informativ måde: lokalt plausible, globalt nonsens. Hvert tilstødende bogstavpar i momakurailezitynn er et par, der forekommer i rigtige navne; der er bare sytten af dem i træk. Modellen har ét bogstavs hukommelse, så den kan ikke vide, at den har været i gang for længe.

Loss på held-out navne er 2,4546 nats. Det tal betyder intet i sig selv, og derfor findes perplexity:

Skrevet ud, uden at et library gør arbejdet:

@torch.no_grad()
def perplexity(logits, Y):
    logp = F.log_softmax(logits, dim=1)          # log q for every symbol
    chosen = logp[torch.arange(len(Y)), Y]       # log q of the one that came next   
    return torch.exp(-chosen.mean())             

Eksponentiering fortryder logaritmen og returnerer tallet til enheden for at tælle ting. Den rene måde at se, hvad det tæller, er at måle en model, der slet intet ved — en, der tildeler sandsynlighed $1/27$ til hvert symbol uanset context:

uniform over 27 symbols            loss 3.2958 nats   ppl  27.000
bigram counts, add-one smoothed    loss 2.4546 nats   ppl  11.642

Præcis 27,000, fordi $e^{\log 27} = 27$. Perplexity er det effektive antal lige sandsynlige muligheder, modellen vælger imellem. En perplexity på 27 betyder "ingen idé, det kan være hvad som helst". Count-modellens 11,642 betyder, at ét bogstavs context efterlader den lige så usikker som en person, der vælger blindt mellem cirka tolv muligheder i stedet for syvogtyve — og derfor citeres perplexity, mens rå loss ikke gør.

To ting går galt med den, og den anden går galt i publicerede papers.

Nulsandsynligheder er fatale. Af de 729 celler i tabellen forekommer 113 aldrig i træningen — 15,5 % af den er tom. Det er fint, indtil held-out-sættet lander i en af dem, og det gør syv bigrams i valideringen, blandt dem d→q, z→j og q→o to gange. Sandsynlighed nul betyder log $-\infty$, hvilket betyder uendelig loss og uendelig perplexity: Ét navn ud af tre tusind ødelægger metrikken. Den sædvanlige lap er at lægge 1 til hvert count før normalisering, hvilket næsten ikke koster noget her (2,4546 i stedet for 2,4524). Men lappen er en indrømmelse. En count-model kan slet ikke generalisere. Den har ingen måde at mistænke, at q→o er plausibelt, fordi q→u er almindeligt, og o opfører sig som u andre steder, eftersom den ikke har nogen idé om, at to symboler kan ligne hinanden. Hver celle læres alene, og at fikse det er, hvad resten af dette kapitel handler om.

Perplexity er en pris per token, og token er en fri parameter. Det er fejlen, der konstant dukker op, når modeller sammenlignes, og den er nem at se, når først du kigger. Tag det samme korpus af engelsk prosa fra kapitel 7, den samme interpolerede bigram-model, og ændr kun, hvordan teksten skæres op:

Perplexity varierer med en faktor 25 på tværs af de rækker. Intet ved modellen ændrede sig; kun størrelsen på den ting, der skulle forudsiges. At forudsige et helt ord er sværere end at forudsige et bogstav, så det koster mere per prediction — og der er færre predictions at lave.

Læs nu den sidste kolonne, som i stedet dividerer den samlede cost med antallet af tegn og konverterer den til bits. Den omordner tabellen. Efter perplexity er rangeringen tegn, ord, BPE-512, BPE-2048; efter bits per tegn er den ord, BPE-2048, BPE-512, tegn. Tegnmodellen går fra førsteplads til sidsteplads. Modellen med 2.048 merges, som efter perplexity ser 6,6 gange dårligere ud end modellen med 512 merges, er faktisk den bedste af de to med 2,4254 bits mod 2,6407.

Så en perplexity kan kun sammenlignes mellem to modeller, der deler tokenizer, og modeller med forskellige tokenizers kan kun sammenlignes i bits per tegn — den størrelse Shannon målte i 1951 ved at få menneskelige forsøgspersoner til at gætte næste bogstav i engelsk tekst og afgrænsede til omtrent én bit per tegn.² Vores bedste bigram ligger på 2,23 bits, hvilket er en rimelig opsummering af, hvor langt dette kapitel stadig skal.

Byg nu den samme model som et netværk. Den vil kræve størrelsesordener mere aritmetik for at nå frem til det samme sted, og det er pointen, at den når frem til det samme sted.

Erstat tabellen med én vægtmatrix $W$ med formen $27 \times 27$. Gør det aktuelle bogstav til en one-hot-vektor, multiplicér, og kald resultatet logits — de unormaliserede scores fra kapitel 4. Så softmax, så cross-entropy, så gradient descent.

W = torch.randn((27, 27), requires_grad=True)

for step in range(3000):
    logits = W[xs]                            
    loss = F.cross_entropy(logits, ys)
    W.grad = None
    loss.backward()
    W.data -= 50.0 * W.grad

Den fremhævede linje indeholder en definition, der er værd at have. At multiplicere en one-hot-vektor med en matrix vælger én række i den, så multiplikationen er et lookup — og enhver implementation springer aritmetikken over og laver lookup direkte, hvilket er det, W[xs] er.

Det er en embedding-tabel. En matrix med én række per vocabulary entry, indekseret af token id. Ingen geometri, ingen semantik, ingen separat algoritme: en lookup-tabel, hvis indhold tilfældigvis læres af gradient descent sammen med alt andet. Enhver mystisk påstand om "embedding space" bunder her.

Træn den, og se, hvor den går hen:

  step     1   train 3.7550   val 3.3882   max gap to the count table 0.757269
  step   100   train 2.4732   val 2.4726   max gap to the count table 0.388354
  step  1000   train 2.4557   val 2.4549   max gap to the count table 0.041862
  step  3000   train 2.4547   val 2.4544   max gap to the count table 0.004048

Den sidste kolonne er den største absolutte forskel mellem en hvilken som helst celle i softmax(W) og den matchende celle i count-tabellen, og den går mod nul. Efter 3.000 trin er den største uenighed nogen steder i de 729 celler 0,004048, og gennemsnittet er 0,000224. Den værste celle er q→i, set tolv gange i hele træningssættet; blandt de 22 rækker med mere end tusind forekomster er den værste uenighed 0,000562.

                 count table   network
    a -> '.'        0.1945     0.1945
    a -> 'n'        0.1601     0.1601
    a -> 'r'        0.0967     0.0967

Gradient descent, startet fra tilfældige tal og uden anden instruktion end "gør log-sandsynligheden for næste bogstav stor", genfandt count-tabellen. Og det var den nødt til: Counts er maximum-likelihood-estimatet, cross-entropy er den negative log-likelihood, så begge procedurer optimerer det samme objective, og det objective har ét optimum. Netværket lærte ikke noget, der var som counting. Det konvergerede mod counting, langsomt.

Hvilket rejser det fair spørgsmål om, hvorfor nogen skulle gide. Fordi count-tabellen ikke har nogen steder at gå hen herfra, og netværket har.

Udvid modellen, så den ser på mere end ét foregående tegn. Dette er Bengios arkitektur fra 2003, den direkte forfader til hver model i resten af dette kursus:⁴ Tag de sidste tre tegn, map hvert gennem en embedding-tabel til en 10-dimensionel række, konkatenér rækkerne til 30 tal, skub dem gennem det hidden layer fra kapitel 5, og slut af med et output layer, der producerer én logit per vocabulary entry.

C  = torch.randn((27, 10))          # the embedding table
W1 = torch.randn((3 * 10, 200))     # the hidden layer from Chapter 5
W2 = torch.randn((200, 27))         # one output per vocabulary entry

emb = C[X].view(-1, 30)             # three lookups, concatenated   
h = torch.tanh(emb @ W1 + b1)
logits = h @ W2 + b2                
loss = F.cross_entropy(logits, Y)

Bemærk, hvad der er nyt, og hvad der ikke er. Det hidden layer er kapitel 5's, uændret; loss er kapitel 4's, uændret. Nyhederne er embedding-tabellen i fronten og et output layer, der er lige så bredt som kapitel 7's vocabulary — og den anden er den dyre del af enhver sprogmodel, der nogensinde er bygget, fordi et rigtigt vocabulary har 100.000 entries, og denne matrixmultiplikation kører ved hver position.

Den samme kode, trænet identisk, med kun størrelsen på context window ændret:

Den anden række er den interessante. Et netværk med et hidden layer på 200 units og elleve gange så mange parametre som count-tabellen klarer sig præcis lige så godt som count-tabellen og ikke bedre. Kapacitet var aldrig begrænsningen. Ét tegns context tillader en bestemt loss, og intet, du bolter på, kan komme under den, fordi informationen ikke er der.

Giv den tre tegn, og perplexity falder fra 11,68 til 8,29 — et fald på 29 %, købt med 4.000 ekstra parametre. Den slår counting her af præcis den grund, der blev diagnosticeret tidligere: En count-model over context på tre tegn behøver $27^3 = 19{,}683$ rækker, de fleste af dem tomme eller med én enkelt observation, og den lærer hver af dem alene. Netværket deler. Hvis a, e og i ender med lignende embedding-rækker, overføres det, den lærer efter bra, til bre, uden at den nogensinde har set bre. Den overførsel er hele værdien af embedding-tabellen, og det er kløften mellem række to og tre.

Samples bliver tilsvarende bedre:

deliah   nellara   joce     kael      quintis
salayson  reety    khyrmin  mahnen    madiaryxia

Stadig ikke en liste over rigtige navne. Men deliah, nellara og kael ville ikke se malplacerede ud på en, og de endeløse monstre er væk: Den længste af tyve samples fra count-modellen er nitten bogstaver, den længste af tyve fra denne er tretten.

Tabellen er $27 \times 10$: én række med ti tal per tegn, alle initialiseret tilfældigt og kun flyttet af gradienten fra næste-tegn-loss. Ingen lagde noget derind. Så hvad endte der i den?

Værktøjet til at spørge er cosine similarity, som er prikproduktet fra kapitel 1 med længderne divideret ud:

Det måler vinklen mellem to vektorer og ignorerer deres længder, hvilket er det, du vil have, når en rækkes længde afspejler, hvor ofte dens token optrådte, snarere end hvad den betyder. Normalisér først hver vektor til længde 1 — som rigtige systemer gør, én gang, ved indeksering — og cosine similarity er simpelthen prikproduktet.

Her er de nærmeste naboer for et par tegn i den trænede tabel:

  'c' -> 'k':+0.598      'j' -> 'z':+0.650      'i' -> 'y':+0.541
  'u' -> 'e':+0.482      'a' -> 'h':+0.367      '.' -> 'q':+0.077

Noget af det er, hvad folkloren lover. c og k kan byttes ud i navne, og det samme kan i og y; j og z er begge sjældne, mest initiale konsonanter, der opfører sig ens. Grænsesymbolet . er tæt på slet ingenting — 0,077 til det nærmeste bogstav — fordi det er det eneste symbol, der markerer en position snarere end en lyd.

Og noget af det er ikke. Den nærmeste nabo til a er h, ikke en anden vokal. Gennemsnitligt over alle par:

mean cosine, vowel to vowel         : +0.1889
mean cosine, consonant to consonant : +0.0765
mean cosine, vowel to consonant     : -0.0042

Vokalerne ligner hinanden mere, end de ligner konsonanter, og effekten er reel, men lille. Testet mod 2.000 tilfældigt valgte grupper af fem bogstaver separerer 58 af de grupper mindst lige så rent — et gap signifikant ved cirka $p = 0.03$. Altså reel, men slet ikke som den skarpe geometriske ø, populære forklaringer af embeddings antyder.

Det er den ærlige beskrivelse af en embedding-tabel, og den er værd at holde fast i gennem resten af kurset. Den er ikke et kort over betydning. Den er en ændring af koordinater, lært snarere end designet, hvis eneste opgave er at gøre næste layers arbejde nemt — den samme sætning, kapitel 5 brugte om det hidden layer, der foldede planet for at løse XOR. Enhver struktur, du finder i den, er der, fordi den sænkede loss, og struktur, der ikke sænker loss, er der simpelthen ikke.

Hvis den nyttige del er tabellen, kan du gå direkte efter den. Det er word2vec: behold embedding lookup, smid sprogmodellen væk.⁵

Objective for skip-gram with negative sampling er én linje. For et rigtigt (center, context)-par trukket fra korpuset skal deres prikprodukt skubbes op; for $k$ falske par trukket fra en støjdistribution skal det skubbes ned:⁶

Det er en binær klassifikation — "optrådte disse to ord virkelig sammen?" — og det er billigt netop fordi det aldrig rører hele vocabulary, hvilket gjorde træning på milliarder af ord praktisk i 2013. GloVe ankommer til lignende vektorer fra den anden retning ved at faktorisere matricen af globale co-occurrence counts i stedet for at streame gennem eksempler.⁷ Begge er fitted til præcis den statistik, count-tabellen blev bygget fra. De er counting, komprimeret.

Trænet på text8 — 17.005.207 ord fra engelsk Wikipedia, 71.290 af dem forekommende mindst fem gange, 100 dimensioner, tre gennemløb — kommer vektorerne ud med den egenskab, der gjorde dem berømte:

king     -> charles 0.700, son 0.693, queen 0.686, henry 0.669, throne 0.667
physics  -> chemistry 0.672, electromagnetism 0.661, quantum 0.654, theoretical 0.624
guitar   -> bass 0.733, vocals 0.732, acoustic 0.728, guitars 0.703, drums 0.685
three    -> seven 0.892, two 0.877, one 0.875, five 0.871, four 0.870

Ingen leverede en kategori for instrumenter eller talord. Nu den berømte del: Tag king, træk man fra, læg woman til, og find den nærmeste vektor til resultatet.

king - man + woman
   nothing excluded : king 0.693, elizabeth 0.657, wife 0.629, woman 0.607
   a, b, c excluded : elizabeth 0.657, wife 0.629, mary 0.607   (queen is 4th, 0.604)

Den nærmeste vektor til king - man + woman er king. Det er ikke et særtilfælde fra ét eksempel. Mikolovs evalueringssæt stiller spørgsmål på formen a : b :: c : ? — 8.869 semantiske (paris : france :: rome : italy) og 10.675 syntaktiske (walking : walked :: swimming : swam) — og på tværs af de 4.103 semantiske spørgsmål, dette vocabulary kan besvare, er vinderen et af de tre inputord 99,8 % af tiden. De publicerede demonstrationer nævner det ikke, fordi standardscoringsreglen sletter a, b og c, før den kigger. Det er en legitim regel, og den udfører mere arbejde end aritmetikken:

Den tredje række er den, du skal blive ved. Smid a og b væk, lav slet ingen aritmetik, returnér hvad end der er nærmest c — og du beholder 77 % af den semantiske score. Det meste af det, der ligner analogisk ræsonnement, er nærhed plus en regel, der forbyder de åbenlyse svar, hvilket er det, Linzen målte på ordentligt trænede vektorer, og det baselines ovenfor replikerer.⁸ Disse specifikke vektorer er små — 17 millioner ord mod milliarderne bag de publicerede modeller — så læs procenterne som en form, ikke som state of the art. Formen er det, der overlever på enhver skala: Aritmetikken er reel og langt svagere end den ene demonstration, alle citerer.

Alt indtil nu har en hård grænse indbygget i datastrukturen. En tabel har én række per token. Ordet bank får én vektor, den samme i en sætning om en flod og en sætning om et realkreditlån — nødvendigvis, fordi et lookup efter id ikke kan afhænge af noget andet.

Løsningen er at stoppe med at læse vektoren ud af tabellen og begynde at beregne den fra sætningen. Det er en contextual embedding, introduceret af ELMo i 2018 og gjort standard af BERT samme år.⁹¹⁰ Målt på den rigtige model er tallene skarpere end forklaringen:

sentence A: "He sat on the bank of the river and watched the water go by."
sentence B: "She deposited the cheque at the bank on the corner of the street."

static vector for 'bank' (a row of the input embedding table)
    cosine A vs B ........................ 1.000000

contextual vector for 'bank', layer by layer
    layer  |  A vs B  |  A vs another river sentence  |  B vs another money sentence
        0  |  0.9512  |            0.9512             |            0.9359
        4  |  0.5647  |            0.8987             |            0.7716
        9  |  0.4284  |            0.8699             |            0.7568
       12  |  0.5278  |            0.8702             |            0.7335

Den første række er præcis, ikke omtrentlig: Den statiske vektor for bank er de samme 768 tal i begge sætninger, så cosinus er 1 per konstruktion. Ni layers senere ligger de to forekomster på 0,43, mens bank i to forskellige flodsætninger bliver på 0,87. Ingen labelled en betydning nogen steder i denne proces; betydningerne skilte sig ud, fordi det at skille dem ud gør trænings-objective — at gætte en skjult token fra dens naboer — lettere at opfylde.

To detaljer betaler sig at lægge mærke til. Layer 0 er allerede 0,9512 snarere end 1,0, fordi position embeddings er blevet lagt til, og ordet står et andet sted i hver sætning. Og ligheden stiger igen ved layers 11 og 12: De sidste layers i en pretrained model er specialiseret til dens trænings-objective og er ofte ikke det bedste sted at tage en representation fra.

For at søge i et korpus efter betydning har du brug for én vektor per sætning. Givet dem er søgningen trivial — det er hele semantic retrieval, og kapitel 19 handler om alt omkring det:

E = normalise(embed(sentences))       # (200, d), every row of length 1
q = normalise(embed([query]))         # (1, d)
scores = q @ E.T                      # one matrix multiply   
top5 = scores[0].argsort()[::-1][:5]

Så det eneste rigtige spørgsmål er, hvor embed kommer fra. Det oplagte træk er at tage en pretrained sprogmodel, køre hver sætning gennem den og tage gennemsnittet af token-vektorerne. Her er den metode mod fire alternativer, scoret på to måder: rank correlation mellem cosinus og menneskelige lighedsbedømmelser over de 1.379 par i STS-benchmarket, og top-1 retrieval på et index bygget fra de 200 stærkest parafraserede af de par — den ene side af hvert par indekseret, den anden brugt som query.

Læs de tre midterste rækker op mod de to første. En pretrained transformer med 109 millioner parametre, brugt på den oplagte måde, er dårligere til at bedømme sætningslighed end at tælle, hvor mange ord to sætninger deler — og dårligere end at tage gennemsnittet af de 100-dimensionelle text8-vektorer, der blev trænet for et øjeblik siden. [CLS] token, som tutorials stadig anbefaler, fordi BERT blev pretrained med et objective på sætningsniveau knyttet til den, er værre end halvdelen af det.

Det er ikke en defekt i BERT. Det er objective. En sprogmodel trænes, så dens hidden states forudsiger en token; intet der beder to parafraser ende tæt på hinanden, og intet belønner en geometri, hvor cosinus betyder "samme betydning". Den sidste række er en model en femtedel af størrelsen (22.713.216 parametre), trænet på en helt anden loss: contrastive learning, hvor eksemplerne er par — et spørgsmål og dets svar, en sætning og dens parafrase — og objective trækker sande par sammen, mens sampled negatives skubbes fra hinanden. Det er Sentence-BERTs bidrag og oprindelsen til hele embedding-model-industrien.¹² Dense Passage Retrieval anvender samme opskrift direkte på søgning med én encoder til queries og én til passages.¹³

Så den praktiske regel:

Kapitel 19 bygger et production retrieval-system på dette fundament og ender med en konkret cosinus-cut-off. Den sidste måling i dette kapitel er det, der gør sådan et tal forsvarligt snarere end magisk.

Rigtige embeddings har hundreder eller tusinder af komponenter, og afstande opfører sig mærkeligt deroppe. Tag 1.000 tilfældige punkter i enhedskuben med $d$ dimensioner, og se på forholdet mellem den største og den mindste afstand mellem to af dem:

I ti tusind dimensioner er det fjerneste par punkter kun 6 % længere fra hinanden end det nærmeste par. Alt er omtrent lige langt fra alt andet, "nearest neighbour" holder op med at bære ret meget information, og det er dimensionalitetens forbandelse — såvel som én grund til, at store vector databases ikke laver exact nearest-neighbour search. Den anden side af samme mønt er det, der gør cosinus-tærskler brugbare: Målt over tusind par tilfældige enhedsvektorer ligger middel-cosinus på $-0.0052$ i 100 dimensioner og $+0.0003$ i 768, med standardafvigelser på 0,0968 og 0,0357 — og i 768 dimensioner overstiger kun 0,2 % af tilfældige par 0,1 i absolut værdi. En målt similarity på 0,4 er derfor ikke "40 % ens"; den ligger langt uden for alt, tilfældighed producerer, og derfor separerer tærskler mellem 0,3 og 0,7 signal fra støj i stedet for at ligge midt i den.

Modellen i dette kapitel læser et fast antal foregående tegn, slår hvert af dem op og limer resultaterne sammen i rækkefølge. Det design har to problemer, og de er det samme problem.

Se igen på context-tabellen: At gå fra tre tegn til otte fordoblede næsten parametrene og købte 0,06 nats. Omkostningen vokser lineært med context — hver ekstra position kræver sin egen plade af den første vægtmatrix — og gevinsten gør ikke. Skub den til tusind tokens, og det første layer alene vejer mere end resten af modellen, det meste brugt på positioner, der ikke betyder noget for en given prediction.

Hvilket er det andet problem: Modellen har ingen måde at beslutte, hvilke af de foregående tokens der betyder noget. Position to får sine egne vægte, og position syv får sine egne, permanent, uanset hvad der står i dem. Når modellen staver nell, er det afgørende tegn det umiddelbart foregående. Når en sætning indeholder et pronomen, kan ordet, der fastlægger dets referent, være fyrre tokens tilbage — og ingen fast slot kan tildeles "fyrre tilbage", fordi næste gang vil det være seks.

Det, vi vil have, er en model, der for hver prediction beregner, hvor meget hver tidligere token skal tælle — vægte over context produceret af indholdet snarere end fastlagt af layoutet. Skriv det omhyggeligt ned, og det begynder som noget helt hverdagsagtigt: et gennemsnit over de foregående tokens. Lad så vægtene i det gennemsnit blive lært, og lad dem afhænge af, hvilken token der spørger.

Det er attention, og det er kapitel 9.

Også værd at læse ved siden af: kapitel 3 i Jurafsky og Martins Speech and Language Processing, som behandler n-gram-modeller, smoothing og perplexity langt mere omhyggeligt, end der er plads til her, inklusive hvorfor interpolation og back-off slår at lægge én til; Stanford CS229-noterne §17.1–17.2 om sprogmodellering fra den probabilistiske side; og Linzens paper ovenfor, som er kort og værd at læse i sin helhed.