Next-token tahmini: embedding’ler ve perplexity ne anlama gelir

Chapter 7 seni bir tamsayı dizisiyle ve birinin neden diğerinden sonra geldiğine dair hiçbir gerekçeyle bırakmıştı. İşte gerekçe; Chapter 2’nin tek satırı.

Bir language model, şimdiye kadarki token’ları alan ve sırada hangi token’ın geleceğine dair bir dağılım döndüren bir fonksiyondur: vocabulary’deki her giriş için bir sayı, negatif olmayan, toplamı bir. Başka hiçbir şey değil. Buradan bütün bir document için olasılığa geçmek için olasılığın zincir kuralını uygula:

Bu bir kimliktir; herhangi bir şeyin herhangi bir dizisi için doğrudur, ek varsayım yoktur. Yani küçük işi yapan bir model — önceki token’lar verildiğinde next token — zaten her olası document’e tam ve bedavadan bir olasılık atama gibi büyük işi de yapmıştır. Bunun ucuz bir numara gibi sunulan popüler çerçevesi ("sadece sonraki kelimeyi tahmin ediyor") mantığı ters kurar: next token’ı tahmin etmek joint distribution’ı modellemektir. Yapılacak ikinci bir şey hiç olmadı.

Loss da aynı mekaniklikle gelir. Her konumda model bir dağılım $q$ üretir ve doğru cevap tek bir bilinen token’dır; bu yüzden Chapter 4’ün çapraz entropisi değişmeden uygulanır:

Bu ortalama negatif log-likelihood’tur — Chapter 2’nin tarifinde Gaussian’ın oturduğu yere categorical distribution konmuş hali. Ve true distribution one-hot olduğu için entropy’si sıfırdır; dolayısıyla Chapter 4’ün kimliği gereği çapraz entropi KL divergence’a eşittir: bu sayıyı düşürmek ile modelin inançlarını data’nınkine yaklaştırmak aynı eylemdir.

Bir sonuç kendi cümlesini hak ediyor, çünkü bütün alanın altındaki ekonomik gerçek bu. Etiketler, data’nın bir konum kaydırılmış halidir. Kimse hiçbir şeyi annotate etmez. Bir trilyon token metin, bir trilyon önceden etiketlenmiş örnektir; modern bir modelin training corpus’unun "birinin oluşturduğu dataset" değil de "internet" olmasının nedeni budur.

Herhangi bir network’ten önce baseline: 32.033 isim, satır başına bir tane, ve görev bunlardan harf harf daha fazlasını üretmek.¹

Vocabulary 26 harf artı bir ismin hem başlangıcını hem sonunu işaretleyen boundary symbol .’den oluşur; yani model isimlerin nerede başladığını ve nerede durduğunu öğrenmek zorunda. Bu 27 sembol eder ve mümkün olan en küçük model, her sembolün her başka sembolden sonra ne kadar sık geldiğini gösteren bir tablodur.

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   

İki satır aritmetik ve model fit edildi — üstelik bu bir heuristic değil: sayımları satır toplamlarına bölmek categorical distribution için maximum-likelihood estimate’tir; Chapter 2’nin tarifinin calculus’ü zaten yapılmış hali.

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

Ondan sample al — mevcut harfin satırından bir harf seç, o satıra geç, boundary symbol gelene kadar tekrarla — ve bu bölümün başındaki isimleri elde edersin. Belirli ve öğretici bir şekilde başarısız olurlar: locally plausible, globally nonsense. momakurailezitynn içindeki her yan yana harf çifti gerçek isimlerde görülen bir çifttir; sadece üst üste on yedi tanedir. Modelin belleği bir harftir, bu yüzden çok uzun süredir devam ettiğini bilemez.

Held-out isimlerdeki loss 2,4546 nats. Bu sayı tek başına hiçbir şey ifade etmez; perplexity’nin var olmasının nedeni bu:

İşi yapan hiçbir library olmadan açıkça yazınca:

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

Üstel almak logaritmayı geri alır ve sayıyı şeyleri sayma birimlerine döndürür. Ne saydığını görmenin temiz yolu, hiçbir şey bilmeyen bir modeli ölçmektir — context ne olursa olsun her sembole $1/27$ olasılığı atayan bir modeli:

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

Tam olarak 27,000, çünkü $e^{\log 27} = 27$. Perplexity, modelin aralarından seçim yaptığı eş olasılıklı seçeneklerin effective sayısıdır. 27 perplexity "hiç fikrim yok, her şey olabilir" demektir. Sayım modelinin 11,642 değeri, bir harflik context’in onu yirmi yedi yerine yaklaşık on iki seçenekten körlemesine seçim yapan biri kadar belirsiz bıraktığı anlamına gelir — bu yüzden ham loss değil perplexity alıntılanır.

İki şey ters gider; ikincisi yayımlanmış makalelerde de ters gider.

Sıfır olasılıklar ölümcüldür. Tablodaki 729 hücrenin 113’ü training’de hiç görülmez — %15,5’i boştur. Held-out set bunlardan birine düşene kadar sorun yoktur; validation’da yedi bigram düşer, aralarında d→q, z→j ve iki kez q→o vardır. Sıfır olasılık log $-\infty$ demektir; bu da sonsuz loss ve sonsuz perplexity demektir: üç bin isimde bir isim metric’i yok eder. Alışılmış yama, normalize etmeden önce her sayıma 1 eklemektir; burada neredeyse hiçbir maliyeti yoktur (2,4524 yerine 2,4546). Ama yama bir itiraftır. Bir sayım modeli hiç generalise edemez. q→o’nın plausible olduğunu, çünkü q→u’nın yaygın olduğunu ve o’nın başka yerlerde u gibi davrandığını sezmesinin hiçbir yolu yoktur; çünkü iki sembolün birbirine benzeyebileceği diye bir kavramı yoktur. Her hücre tek başına öğrenilir ve bunu düzeltmek bu bölümün geri kalanının konusudur.

Perplexity token başına bir fiyattır ve token serbest bir parametredir. Modeller karşılaştırılırken sürekli görülen hata budur; bir kez bakınca görmek kolaydır. Chapter 7’deki aynı İngilizce prose corpus’unu, aynı interpolated bigram modelini al ve yalnızca metnin nasıl parçalandığını değiştir:

Perplexity bu satırlar arasında 25 kat değişir. Model hakkında hiçbir şey değişmedi; yalnızca tahmin edilen şeyin boyutu değişti. Bütün bir kelimeyi tahmin etmek bir harfi tahmin etmekten daha zordur, bu yüzden tahmin başına daha pahalıdır — ve yapılacak daha az tahmin vardır.

Şimdi toplam maliyeti bunun yerine karakter sayısına bölen ve bit’e çeviren son sütunu oku. Tablonun sırasını değiştirir. Perplexity’ye göre sıralama karakterler, kelimeler, BPE-512, BPE-2048’tir; karakter başına bit’e göre kelimeler, BPE-2048, BPE-512, karakterlerdir. Karakter modeli birincilikten sonunculuğa iner. Perplexity’ye göre 512-merge olandan 6,6 kat kötü görünen 2.048-merge modeli, aslında 2,6407’ye karşı 2,4254 bit ile ikisinin daha iyisidir.

Yani bir perplexity yalnızca aynı tokenizer’ı paylaşan iki model arasında karşılaştırılabilir; farklı tokenizer’lara sahip modeller yalnızca karakter başına bit ile karşılaştırılabilir — Shannon’ın 1951’de insan deneklere İngilizce metnin sonraki harfini tahmin ettirerek ölçtüğü ve kabaca karakter başına bir bit ile sınırladığı nicelik.² En iyi bigram’ımız 2,23 bit’te duruyor; bu da bu bölümün daha ne kadar yolu olduğunu gayet iyi özetliyor.

Şimdi aynı modeli bir network olarak kur. Aynı yere varmak için büyüklük mertebeleri kadar daha fazla aritmetik yapacak; zaten mesele de aynı yere varması.

Tabloyu shape’i $27 \times 27$ olan bir weight matrix $W$ ile değiştir. Mevcut harfi one-hot vector’e çevir, çarp ve sonuca logits de — Chapter 4’ten bildiğimiz normalize edilmemiş skorlar. Sonra softmax, sonra çapraz entropi, sonra 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

Vurgulanan satır, sahip olmaya değer bir tanım içerir. One-hot vector’ü bir matrix ile çarpmak onun bir satırını seçer; yani çarpma bir lookuptır — ve her implementation aritmetiği atlayıp lookup’ı doğrudan yapar; W[xs] de budur.

Bu bir embedding tablosudur. Vocabulary entry başına bir satırı olan, token id ile index’lenen bir matrix. Geometri yok, semantics yok, ayrı algorithm yok: içerikleri gradient descent ile diğer her şeyle birlikte öğrenilmiş bir lookup table. "Embedding space" hakkındaki her mistik iddia eninde sonunda burada biter.

Eğit ve nereye gittiğini izle:

  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

Son sütun, softmax(W)’nin herhangi bir hücresi ile sayım tablosundaki eşleşen hücre arasındaki en büyük absolute difference’tır ve sıfıra gider. 3.000 step’ten sonra 729 hücrenin herhangi bir yerindeki en büyük anlaşmazlık 0,004048, ortalama ise 0,000224’tür. En kötü hücre, tüm training set’te on iki kez görülen q→i’dür; binden fazla occurrence olan 22 satır arasında en kötü anlaşmazlık 0,000562’dir.

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

Rastgele sayılardan başlayan ve kendisine "next letter’ın log-probability’sini büyük yap" dışında hiçbir şey söylenmeyen gradient descent, sayım tablosunu yeniden keşfetti. Zaten keşfetmek zorundaydı: sayımlar maximum-likelihood estimate’tir, çapraz entropi negative log-likelihood’tur; yani iki prosedür de aynı objective’i optimize eder ve o objective’in tek bir optimum’u vardır. Network saymaya benzer bir şey öğrenmedi. Yavaşça saymaya converge etti.

Bu da adil bir soruyu doğurur: O halde neden biri zahmet etsin? Çünkü sayım tablosunun buradan gidecek yeri yok; network’ün var.

Modeli birden fazla önceki karaktere bakacak şekilde genişlet. Bu Bengio’nun 2003 architecture’ıdır; bu course’un geri kalanındaki her modelin doğrudan atasıdır:⁴ son üç karakteri al, her birini bir embedding table üzerinden 10-dimensional satıra map et, satırları 30 sayı halinde concatenate et, Chapter 5’in hidden layer’ından geçir ve vocabulary’deki her entry için bir logit üreten output layer ile bitir.

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)

Neyin yeni, neyin yeni olmadığına dikkat et. Hidden layer Chapter 5’inkiyle aynı, değişmedi; loss Chapter 4’ünkiyle aynı, değişmedi. Yenilikler öndeki embedding table ve Chapter 7’nin vocabulary’si kadar geniş bir output layer — ve bu ikincisi şimdiye kadar kurulmuş her language model’in pahalı kısmıdır, çünkü gerçek bir vocabulary’de 100.000 entry vardır ve bu matrix multiply her konumda çalışır.

Aynı code, aynı şekilde eğitilmiş, yalnızca context window boyutu değiştirilmiş:

İlginç olan ikinci satırdır. 200-unit hidden layer’a ve sayım tablosunun on bir katı kadar parametreye sahip bir network, sayım tablosuyla tam olarak aynı performansı gösterir ve daha iyisini yapamaz. Sınırlama hiçbir zaman capacity değildi. Bir karakterlik context belli bir loss’a izin verir ve üzerine ne eklersen ekle onun altına inemezsin, çünkü bilgi orada değildir.

Ona üç karakter ver ve perplexity 11,68’den 8,29’a düşer — 4.000 ekstra parametreyle alınmış %29’luk bir kesinti. Burada saymayı tam da daha önce teşhis edilen nedenle yener: üç karakterlik context’ler üzerinde bir sayım modelinin $27^3 = 19{,}683$ satıra ihtiyacı vardır; çoğu boş ya da tek bir observation tutar ve her birini yalnız öğrenir. Network paylaşır. Eğer a, e ve i benzer embedding satırlarıyla sonuçlanırsa, bra sonrasında öğrendiği şey, bre’ı hiç görmemiş olsa bile bre’a transfer olur. Bu transfer embedding table’ın tüm değeridir ve ikinci ile üçüncü satır arasındaki farktır.

Samples buna göre iyileşir:

deliah   nellara   joce     kael      quintis
salayson  reety    khyrmin  mahnen    madiaryxia

Hâlâ gerçek isimlerden oluşan bir liste değil. Ama deliah, nellara ve kael böyle bir listede yadırganmazdı; uzayıp giden canavarlar da yok oldu: sayım modelinden alınan yirmi sample’ın en uzunu on dokuz harf, bundan alınan yirmi sample’ın en uzunu on üç.

Tablo $27 \times 10$: karakter başına on sayıdan oluşan bir satır; hepsi random başlatıldı ve yalnızca next-character loss’un gradient’iyle hareket etti. Kimse içine hiçbir şey koymadı. Peki içine ne girdi?

Sormak için araç cosine similarity’dir; Chapter 1’deki dot product’ın uzunluklar bölünmüş halidir:

İki vector arasındaki angle’ı ölçer ve uzunluklarını yok sayar; bir satırın uzunluğu token’ının ne anlama geldiğinden çok ne kadar sık göründüğünü yansıttığında istediğin şey budur. Önce her vector’ü length 1 olacak şekilde normalise et — gerçek sistemlerin indexing time’da bir kez yaptığı gibi — ve cosine similarity basitçe dot product olur.

Trained table’daki birkaç karakterin nearest neighbours’ı şöyle:

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

Bunun bir kısmı folklore’un vaat ettiği şeydir. c ve k isimlerde birbirinin yerine geçebilir; i ve y de öyle. j ve z ikisi de nadir, çoğunlukla başlangıçta gelen ve benzer davranan consonant’lardır. Boundary symbol . hiçbir şeye yakın değildir — en yakın harfine 0,077 — çünkü bir sesi değil bir konumu işaretleyen tek semboldür.

Bir kısmı ise değildir. a’nin nearest neighbour’ı başka bir vowel değil, h’dir. Tüm çiftler üzerinden ortalama alınca:

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

Vowels birbirlerine consonant’lara olduğundan daha benzerdir ve etki gerçek ama küçüktür. Rastgele seçilmiş 2.000 beş harflik gruba karşı test edildiğinde, bu gruplardan 58’i en az bu kadar temiz ayrılır — yaklaşık $p = 0.03$ düzeyinde significant bir gap. Yani gerçek; ama embeddings hakkında popüler anlatıların ima ettiği net geometrik ada gibi hiç değil.

Bir embedding table’ın dürüst tanımı budur ve course’un geri kalanında akılda tutmaya değer. Bu bir meaning haritası değildir. Tasarlanmış değil öğrenilmiş bir coordinates değişimidir; tek işi sonraki layer’ın işini kolaylaştırmaktır — Chapter 5’in XOR’u çözmek için düzlemi katlayan hidden layer için kullandığı cümlenin aynısı. İçinde bulduğun her structure, loss’u düşürdüğü için oradadır; loss’u düşürmeyen structure ise basitçe orada değildir.

Faydalı kısım tabloysa, doğrudan onun peşine düşebilirsin. word2vec budur: embedding lookup’ı tut, language model’i at.⁵

Skip-gram with negative sampling objective’i tek satırdır. Corpus’tan çekilmiş gerçek bir (centre, context) çifti için dot product’larını yukarı it; noise distribution’dan çekilmiş $k$ fake çift için aşağı it:⁶

Bu binary classification’dır — "bu iki kelime gerçekten birlikte geçti mi?" — ve ucuz olmasının nedeni tam vocabulary’ye hiç dokunmamasıdır; 2013’te milyarlarca kelime üzerinde training’i practical yapan şey buydu. GloVe benzer vector’lere diğer yönden gelir: examples üzerinden stream etmek yerine global co-occurrence counts matrix’ini factorize eder.⁷ İkisi de tam olarak sayım tablosunun kurulduğu statistic’e fit edilir. Saymadır, sıkıştırılmış hali.

text8 üzerinde trained — İngilizce Wikipedia’dan 17.005.207 kelime, bunların 71.290’ı en az beş kez geçiyor, 100 dimensions, üç pass — vector’ler onları ünlü yapan property ile ortaya çıkar:

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

Kimse instruments ya da numerals için bir kategori sağlamadı. Şimdi ünlü kısım: king’ı al, man’ı çıkar, woman’ı ekle ve sonuca en yakın vector’ü bul.

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)

king - man + woman’ye en yakın vector king’dir. Bu tek bir örneğin tuhaflığı değildir. Mikolov’un evaluation set’i a : b :: c : ? formunda sorular sorar — 8.869 semantic olan (paris : france :: rome : italy) ve 10.675 syntactic olan (walking : walked :: swimming : swam) — ve bu vocabulary’nin cevaplayabildiği 4.103 semantic soru genelinde kazanan, zamanın %99,8’inde üç input kelimeden biridir. Yayımlanmış demonstrations bundan bahsetmez, çünkü standard scoring rule bakmadan önce a, b ve c’ü siler. Bu meşru bir kuraldır ve arithmetic’ten daha fazla iş yapar:

Üzerinde durulması gereken üçüncü satırdır. a ve b’ü at, hiç arithmetic yapma, c’a en yakın olanı döndür — ve semantic score’un %77’sini korursun. Analogical reasoning gibi görünen şeyin çoğu, proximity artı obvious cevapları yasaklayan bir kuraldır; Linzen’ın properly trained vector’lerde ölçtüğü ve yukarıdaki baselines’ın replicate ettiği şey budur.⁸ Bu particular vector’ler küçüktür — published models’ın arkasındaki milyarlara karşı 17 milyon kelime — bu yüzden yüzdeleri state of the art değil, shape olarak oku. Her scale’de ayakta kalan shape budur: arithmetic gerçektir ve herkesin alıntıladığı tek demonstration’dan çok daha zayıftır.

Şimdiye kadarki her şeyin data structure içinde yerleşik sert bir sınırı var. Bir tabloda token başına bir satır vardır. Bank kelimesi tek bir vector alır; nehir hakkındaki cümlede de mortgage hakkındaki cümlede de aynı vector — zorunlu olarak, çünkü id ile lookup başka hiçbir şeye bağlı olamaz.

Çözüm, vector’ü tablodan okumayı bırakıp onu cümleden hesaplamaya başlamaktır. Bu bir contextual embedding’dir; 2018’de ELMo tarafından tanıtıldı ve aynı yıl BERT ile standard hale geldi.⁹¹⁰ Gerçek model üzerinde ölçüldüğünde sayılar açıklamadan daha nettir:

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

İlk satır approximate değil exact’tir: bank için static vector iki cümlede de aynı 768 sayıdır, dolayısıyla cosine construction gereği 1’dir. Dokuz layer sonra iki occurrence 0,43’te dururken, iki farklı river cümlesindeki bank 0,87’de kalır. Bu süreçte kimse hiçbir yere sense label’ı koymadı; sense’ler ayrıldı çünkü onları ayırmak training objective’i — komşularından hidden token’ı tahmin etmeyi — satisfy etmeyi kolaylaştırır.

İki detay dikkat etmeye değer. Layer 0 zaten 1,0 yerine 0,9512’dir; çünkü position embeddings eklenmiştir ve kelime her cümlede farklı bir yerde durur. Ayrıca similarity layers 11 ve 12’de yeniden yükselir: pretrained model’in final layers’ı training objective’ine specialise olur ve bir representation almak için çoğu zaman en iyi yer değildir.

Bir corpus’u meaning’e göre aramak için cümle başına bir vector gerekir. Bunlar verildiğinde search trivial’dır — semantic retrieval’ın tamamı budur ve Chapter 19 onun etrafındaki her şey hakkındadır:

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]

Dolayısıyla tek gerçek soru embed’nin nereden geldiğidir. Obvious hamle, pretrained language model alıp her cümleyi içinden geçirmek ve token vector’lerinin ortalamasını almaktır. İşte bu method’un dört alternative’e karşı iki şekilde skorlanmış hali: STS benchmark’ındaki 1.379 çift üzerinde cosine ile human similarity judgements arasındaki rank correlation ve bu çiftlerin en güçlü paraphrase edilmiş 200’ünden kurulan bir index’te top-1 retrieval — her çiftin bir tarafı indexed, diğeri query olarak kullanılmış.

Ortadaki üç satırı ilk ikiye karşı oku. Obvious şekilde kullanılan 109 milyon parametreli pretrained transformer, cümle similarity’sini yargılamakta iki cümlenin kaç kelime paylaştığını saymaktan daha kötüdür — ve az önce trained 100-dimensional text8 vector’lerinin ortalamasından da kötüdür. Tutorial’ların hâlâ önerdiği [CLS] token, çünkü BERT sentence-level objective ile pretrained edilmişti, bunun yarısından da kötüdür.

Bu BERT’te bir defect değildir. Objective’tir. Bir language model, hidden states bir token tahmin etsin diye trained edilir; orada iki paraphrase’in birbirine yakın olmasını isteyen hiçbir şey yoktur ve cosine’ın "aynı meaning" anlamına geldiği bir geometry’yi reward eden hiçbir şey yoktur. Son satır, boyutunun beşte biri kadar bir modeldir (22.713.216 parameters) ve bambaşka bir loss üzerinde trained edilmiştir: contrastive learning; examples çiftlerdir — bir soru ve cevabı, bir cümle ve paraphrase’i — ve objective true pairs’i together çekerken sampled negatives’i apart iter. Sentence-BERT’ün contribution’ı ve tüm embedding-model industry’nin origin’i budur.¹² Dense Passage Retrieval aynı recipe’yi search’e doğrudan uygular; queries için bir encoder ve passages için bir encoder ile.¹³

Yani pratik kural:

Chapter 19 bu temel üzerinde production retrieval system kurar ve somut bir cosine cut-off’a varır. Bu bölümdeki son ölçüm, böyle bir sayıyı magic değil defensible yapan şeydir.

Gerçek embeddings yüzlerce ya da binlerce component’e sahiptir ve distances orada tuhaf davranır. $d$ dimensions’lı unit cube içinde 1.000 random point al ve herhangi iki tanesi arasındaki en büyük distance ile en küçük distance arasındaki ratio’ya bak:

On bin dimensions’ta en uzak nokta çifti, en yakın çiftten yalnızca %6 daha uzaktır. Her şey kabaca diğer her şeye eşit uzaklıktadır; "nearest neighbour" fazla bilgi taşımamaya başlar ve dimensionality curse budur — büyük vector database’lerin exact nearest-neighbour search yapmamasının nedenlerinden biri de. Aynı madalyonun diğer yüzü cosine thresholds’u workable yapan şeydir: random unit vector’lerin bin çifti üzerinde ölçüldüğünde mean cosine 100 dimensions’ta $-0.0052$ ve 768’de $+0.0003$ civarındadır; standard deviations 0,0968 ve 0,0357’dir — ve 768 dimensions’ta random pairs’in yalnızca %0,2’si absolute value’da 0,1’i aşar. Bu yüzden ölçülen 0,4 similarity "%40 benzer" değildir; chance’in üreteceği her şeyin çok dışındadır. Bu nedenle 0,3 ile 0,7 arasındaki thresholds, signal’ı noise’dan ayırır; ortasında oturmaz.

Bu bölümdeki model fixed sayıda önceki karakteri okur, her birini lookup eder ve sonuçları order içinde birbirine yapıştırır. Bu design’ın iki problemi var ve ikisi de aynı problem.

Context tablosuna tekrar bak: üç karakterden sekize çıkmak parameters’ı neredeyse ikiye katladı ve 0,06 nats satın aldı. Maliyet context ile linearly büyür — her extra position ilk weight matrix’in kendi slab’ine ihtiyaç duyar — fayda ise büyümez. Bunu bin token’a it ve yalnızca first layer, modelin geri kalanından daha ağır olur; büyük kısmı herhangi bir prediction için önem taşımayan positions’a harcanır.

İkinci problem de bu: modelin önceki token’lardan hangilerinin önemli olduğuna karar verme yolu yoktur. Position two kendi weights’ini alır, position seven kendi weights’ini alır; içlerinde ne olursa olsun kalıcı olarak. Model nell’i spelling ederken decisive character hemen önceki olandır. Bir cümlede pronoun olduğunda, referent’ını belirleyen kelime kırk token geride olabilir — ve hiçbir fixed slot "kırk geride"ye atanamaz, çünkü bir dahaki sefere altı olacaktır.

İstediğimiz şey, her prediction için önceki her token’ın ne kadar sayılması gerektiğini hesaplayan bir modeldir — layout tarafından fixed değil, content tarafından üretilen context üzerindeki weights. Bunu dikkatle yazınca tamamen sıradan bir şey olarak başlar: previous token’lar üzerinde bir average. Sonra o average’ın weights’inin öğrenilmesine izin ver ve weights’in soruyu soran token’a bağlı olmasına izin ver.

Bu attention’dır ve Chapter 9’dur.

Yanında okumaya değer: Jurafsky ve Martin’in Speech and Language Processing kitabının 3. chapter’ı; n-gram models, smoothing ve perplexity’yi burada yer olduğundan çok daha dikkatli ele alır, interpolation ve back-off’un neden one eklemekten iyi olduğunu da dahil eder. Stanford CS229 notes §17.1–17.2, probabilistic taraftan language modelling için; ayrıca yukarıdaki Linzen paper’ı kısa ve baştan sona okumaya değer.