Attention ve Transformer Bloğu: Ortalamadan Türetilmiş Hâli

1997’den yaklaşık 2017’ye kadar özet, tekrarlayan bir state idi: bir vector $\mathbf{h}$ tut ve her token’da onu güncelle, $\mathbf{h}_t = f(\mathbf{h}_{t-1}, \mathbf{x}_t)$. Sabit boyut, değişken input, tam doğru şekil.

Üç şekilde başarısız oldu ve bu bölümün mimarisi üçünü de cevaplıyor. $T$ adım boyunca backpropagation yapmak $T$ Jacobian’larını çarpar, bu yüzden gradient kaybolur ya da patlar — Bölüm 5’in tek bir $\tanh$ node içinde ölçtüğü hastalık. LSTM¹ tam buna karşı tasarlandı ve kullanılabilir aralığı onlarca adımdan yüzlerce adıma taşıdı; ama token 5’ten gelen bilginin token 500’e ancak 495 ardışık güncellemeyi sağ çıkarak ulaşması gerçeğini değiştirmedi. Tüm kaynak tek bir vector’e sığmak zorundaydı: sequence-to-sequence çeviride² bir encoder input’u son state’ine sıkıştırır. Bahdanau, Cho ve Bengio bu darboğazı adlandırdı ve 2014’te, transformer’dan üç yıl önce, decoder’ın kendi hesapladığı ağırlıklarla tüm encoder state’lerinin ağırlıklı toplamını almasına izin vererek düzeltti.³ Aşağıdaki her şey, recurrence silinmiş hâliyle, bu fikrin bir sequence tarafından kendisine uygulanmasıdır. Ve güncelleme yapı gereği ardışıktır: $\mathbf{h}_t$ için $\mathbf{h}_{t-1}$ gerekir; on bin çekirdekli bir GPU bununla hiçbir şey yapamaz. Kazanan mimari bariz biçimde daha zeki olan değil; pahalı adımı bir matris çarpımı olan mimaridir.

Diğer klasik inductive bias, convolution — küçük bir filtreyi tüm input üzerinde kaydırmak, böylece herhangi bir yerde tespit edilen bir özellik her yerde tespit edilir — burada da kurulmayacak; görüntüler için neredeyse tam doğru fikirdir ve bir vision dersine bırakılır. Bu sayfadan sonra ne recurrence ne de convolution yeniden görünür; bu yüzden ikisine de bölüm ayrılmıyor: Bölüm 1 atlamaların sessizce değil, açıkça ilan edileceğine söz vermişti.

Değişken sayıda vector alıp tek vector döndüren en bariz function ortalamadır:

Herhangi sayıda input, sabit output boyutu, differentiable, bedava. Embedding tablosu artı bu ortalama artı vocabulary’ye bir linear layer: on beş satırda tam bir language model. Ayrıca berbat; nasıl berbat olduğu da bütün türetmenin kendisi.

Aşağıdaki corpus bir megabyte Shakespeare, 1.115.394 karakter; Bölüm 7’de kurulan türden, vocabulary’si 1024 olan byte-level BPE tokenizer’dan geçirilmiş: token başına 2,43 karakterle 459.760 token, 90/10 bölünmüş. Her model 128 genişliğinde, 128 token görüyor ve 64’lük batch ile $10^{-3}$’de 3000 AdamW adımı eğitiliyor. Perplexity held-out split üzerinde.⁴

İkinci satırı iki kez oku. Context’i ortalamak azıcık yardımcı olmuyor; modeli context’i tamamen yok saymaktan dört kat kötü yapıyor. İki neden var, ikisi de empirik değil kanıtlanabilir.

Ortalama sırayı göremez. Toplama commutative’dir, bu yüzden window’u karıştırmak özeti değiştirmez — yaklaşık olarak değil:

A = torch.tril(torch.ones(T, T))
A = A / A.sum(1, keepdim=True)          # rows of the averaging matrix
y = x[torch.randperm(T)]                # the same tokens, shuffled
print((A[-1] @ x - A[-1] @ y).abs().max().item())

2.9802322387695312e-08

Yeniden sıralanmış toplamda floating-point gürültüsü: iki özet aynı vector. Context’e yalnızca ortalama üzerinden bakan bir model köpek adamı ısırdı ile adam köpeği ısırdı cümlelerini ayırt edemez. Üçüncü satır bunun input’lara position ekleyerek düzeltilemediğini kanıtlıyor — ortalamadan önce her token’a learned position embedding eklemek 188 puanlık farktan yalnızca 2,14 puan kazandırdı. Position’lar toplama girer ve toplam onları unutur.

Ve ortalama şimdiyi boğar. Position 100’de mevcut token özetin yüzde biridir. Bunun elindeki ucuz bir çözümü var: token’ı koru ve özeti ona ekle — Bölüm 6’dan bir residual connection; dördüncü satır da bunun yaptığı şey. Seyrelme onarıldığında uniform ortalama hiçbir şey katmıyor: 59,71 baseline’a karşı 60,45. Her token orada, eşit ağırlıkla; eşit ağırlıklandırma bilgi olmamasıyla aynıdır.

Problem ortalama almak değil. Problem ağırlıklar.

Büyüyen prefix üzerinde ortalama almak bir loop gibi görünür. Satırları toplamı bir olan alt üçgensel bir matrisle tek bir çarpımdır — ve aynı zamanda, tam olarak, bir softmax’tir:

loop = torch.stack([x[:t + 1].mean(0) for t in range(T)])   # the obvious version

A = torch.tril(torch.ones(T, T))
A = A / A.sum(1, keepdim=True)
mat = A @ x                                                  # the same thing

S = torch.zeros(T, T).masked_fill(torch.tril(torch.ones(T, T)) == 0, float("-inf"))
soft = F.softmax(S, dim=-1) @ x                              # and the same thing again

loop vs matmul   max |diff| = 5.960464477539063e-08
loop vs softmax  max |diff| = 5.960464477539063e-08

the averaging matrix A (rows sum to 1, upper triangle is zero):
  1.000 0.000 0.000 0.000 0.000 0.000
  0.500 0.500 0.000 0.000 0.000 0.000
  0.333 0.333 0.333 0.000 0.000 0.000
  0.250 0.250 0.250 0.250 0.000 0.000
  0.200 0.200 0.200 0.200 0.200 0.000
  0.167 0.167 0.167 0.167 0.167 0.167

Bir transformer’ın üç adlandırılmış bileşeni artık ekranda. Üçgen causal mask’tir, objective tarafından zorunlu kılınır: position $t$ position $t{+}1$’ü görebilseydi cevap input’un içinde olurdu — Bölüm 6’nın denetlemeni söylediği sızıntı, sadece mimarinin içinde. Softmax mask’in uygulanma biçimidir: yasak girişleri $-\infty$ yapmak onları tam olarak sıfıra gönderir ve geriye kalanı normalize eder; yani mask’leme ve normalize etme tek işlemdir. (-1e9 değil $-\infty$ kullan: mask’in anlamı olan değer budur, float16’ya cast edilince $-\infty$ olarak kalır ve seçtiğin constant’ın içinde bulunduğun aralık için yeterince büyük olup olmadığına karar verme zahmetinden kurtarır — bu da Bölüm 2’nin floating-point kutusunun, cevaplamak zorunda olmadığın bir soru sormasıdır.) Ve score’lar serbest parametredir. Uniform ortalama, izin verilen her score aynı sayı olduğunda elde ettiğin şeydir; oraya herhangi sayıları koy, softmax onları geçerli ağırlıklara çevirir.

Bu bölümün geri kalanı tek bir soru: bu sayılar nereden geliyor?

Düz parametreler olamazlar. Learned $T \times T$ matrisi her cümle için aynı olurdu — "dört token geriye bak"ı encode edebilir ama asla "bu pronoun’un refer ettiği isme bak" diyemez. Position $t$ ile position $i$’yi bağlayan ağırlık iki position’da ne olduğuna bağlı olmalıdır; çünkü relevance bir ilişkidir, bir özellik değil: it kelimesi kendi başına relevant değildir, bir şeye göre relevant’tır.

İki vector’den sayı döndüren en ucuz function, Bölüm 1’deki dot product’tır. Position $i$’i position $t$ için $\mathbf{x}_t \cdot \mathbf{x}_i$ olarak score’la ve mekanizma çalışır — ama iki şekilde kötü çalışır ve geri kalan her şeyi zorunlu kılar. Bir vector’ün kendisiyle dot product’ı normunun karesidir, bu yüzden her token çoğunlukla kendisine attend ederdi. Ayrıca ilişki simetrik olurdu: it güçlü biçimde animal’a attend ediyorsa, animal da güçlü biçimde it’e attend ederdi; oysa dilde bu yanlıştır, bir adjective kendi noun’una noun’un adjective’e ihtiyaç duyduğundan çok daha fazla ihtiyaç duyar.

O hâlde her token’a, onun iki learned linear map’i olarak iki rol ver: bu position’ın aradığı şey, $\mathbf{q}_t = W_q\mathbf{x}_t$, yani query; ve kendisinin bulunmak için sunduğu şey, $\mathbf{k}_i = W_k\mathbf{x}_i$, yani key. $\mathbf{q}_t \cdot \mathbf{k}_i$ score’la ve simetri kaybolur, çünkü $W_q \neq W_k$: bir token bir şeyi ilan edip başka bir şeyi arayabilir.

Hâlâ yanlış olan bir şey var. Ağırlıklı toplam $\mathbf{x}_i$’lerin üzerindeydi; bu da kopyalanan şeyin eşleşen şey olmasını zorunlu kılar. Eşleşme bir token’ı tanımlayan özellikleri ister; kopyalama ise downstream’de işe yarayan özellikleri ister. Bu yüzden üçüncü bir map öğren, $\mathbf{v}_i = W_v\mathbf{x}_i$, yani value, ve onları topla.

Formül artık defter tutma:

burada $M$ causal mask’tir; diagonal üzerinde ve altında sıfır, üstünde $-\infty$. Kodda otuz satırdır, bunun yirmisi shape’lerdir:

class Head(nn.Module):
    """One head of causal self-attention."""

    def __init__(self, d_model, d_head, block):
        super().__init__()
        self.q = nn.Linear(d_model, d_head, bias=False)      
        self.k = nn.Linear(d_model, d_head, bias=False)      
        self.v = nn.Linear(d_model, d_head, bias=False)      
        self.d_head = d_head
        self.register_buffer("mask", torch.tril(torch.ones(block, block)).bool())

    def forward(self, x):
        T = x.shape[1]
        q, k, v = self.q(x), self.k(x), self.v(x)
        s = q @ k.transpose(-2, -1) / math.sqrt(self.d_head)          
        s = s.masked_fill(~self.mask[:T, :T], float("-inf"))          
        w = F.softmax(s, dim=-1)                                      
        return w @ v                                                  

Score’la, mask’le, normalize et, karıştır. Geri kalan her şey projection’dır.

$\sqrt{d_k}$ için yapılan neredeyse her açıklama "softmax’in saturation’a girmesini önlemek için" der; doğru ama hiçbir şey açıklamıyor. Argüman, Bölüm 2’deki variance’ın iki satırıdır. $\mathbf{q}$ ve $\mathbf{k}$ girişleri bağımsız, mean’i sıfır ve variance’ı bir ise, her çarpım $q_j k_j$ variance bir taşır ve bağımsız şeylerin variance’ları toplanır:

Yani score’ların standard deviation’ı $\sqrt{d_k}$ olur. Yirmi bin rastgele pair üzerinde ölçülünce:

     d     Var(q.k)         std   sqrt(d)
     4        3.975       1.994     2.000
    16       16.071       4.009     4.000
    64       64.249       8.016     8.000
   256      253.065      15.908    16.000
  1024     1015.562      31.868    32.000

Bunun önemi: softmax, bir linear layer’ın olmadığı şekilde scale-sensitive’dir. Bir linear layer’ın input’unu ikiye katlamak output’unu ikiye katlar; score’ları softmax’ten önce onla çarpmak yumuşak bir karışımı sert bir seçime dönüştürür. 64 score’luk bir satır, bölmeyle ve bölmesiz:

"Effective tokens", entropy’nin üstelidir: satırın gerçekten kaç position üzerinde ortalama aldığı. Bölmesiz durumda, $d_k = 256$’de, yeni initialised edilmiş bir head 64 token’dan tam olarak bir tanesine attend eder; seçim sadece random draw ile yapılır.

Bu forward’da kötü, backward’da daha da kötüdür; Bölüm 5’in bir $\tanh$ üzerinde zaten ölçtüğü şekildedir. Tek entry’ye bağlanmış bir softmax’in neredeyse derivative’ı yoktur: Jacobian’ının diagonal’i $w_i(1-w_i)$’dir, iki uçta da sıfırdır. İki bin rastgele satır üzerinde:

$d_k = 1024$’de, on satırdan yedisi eğitim başlamadan donmuştur; donmuş başlayan bir head neye bakacağını öğrenemez. Bölünmüş durumda bu nicelik her width’te 0,96’da dümdüz kalır ve hiçbir şey saturation’a girmez.

Şimdi kimsenin yayımlamadığı kısım: final perplexity’yi değiştiriyor mu? Bölmeyi sil ve dört head width’te eğit:

İlk iki satır yukarıdaki 3000 adımlık bütçeden geliyor; son üçü daha kısa bir run — 1500 adım, 32’lik batch, bir head, projection’lardan önce normalization yok — ve iki variant da identical settings altında.

$d_k = 32$’de bölme hiçbir şey kazandırmıyor ve bölmesiz run çok az önde. Bu, onu atmak için lisans değildir; çünkü 256’da 18 perplexity puanı, 1024’te 17 puan değerindedir. Mekanizma score’ların kendisinde görünür:

Bölmesiz head toparlanmaz. Kaçar gider: score’larının standard deviation’ı initialisation’da 21’den 5147’ye çıkar, attention entropy sıfıra düşer ve satırların %99,9’u ağırlığının 0,99’dan fazlasını tek bir token’a koyar. Bir head sert selector hâline geldiğinde gradient’i neredeyse sıfırdır ve hiçbir şey onu geri çekmez; collapse bu yüzden stabildir. Bölünmüş head aynı eğitimden sonra 3,44 score standard deviation’da oturur; bu hâlâ değiştirilebilen yumuşak bir karışımdır.

Vaswani et al. tam olarak bunu söyler, daha fazlasını değil — products’ın büyük $d_k$ değerleri için "büyük magnitude’da büyüdüğünden" şüphelenirler ve bölerler.⁵ Büyük kelimesi yük taşır; tablolar da büyüğün nerede başladığını söyler: 32’de hiçbir şey, 256’ya gelindiğinde her şey.

Bir head, position başına bir softmax satırıdır; yani "burada relevant olan nedir" sorusuna tek bir cevap tutar. the animal that crossed the wet street içindeki the sonrasındaki kelimeyi tahmin etmek, syntactic slot’u, subject’i ve önceki token’ı aynı anda gerektirir; tek bir probability distribution üç yere yoğunlaşamaz. O yüzden birden fazla head’i paralel çalıştır, her biri $d_{\text{model}}/h$ width’te olsun, concat et ve bir matris daha, $W_o$, ile karıştır: width’i parçalara böldün, ona ekleme yapmadın.

Attention ayrıca tam olarak tek bir şey yapar — bilgiyi position’lar arasında taşır. Yukarıdaki koddaki her operation feature axis boyunca linear’dır ve Bölüm 5 bir linear map stack’inin ne olduğunu kanıtlamıştı. Bu yüzden her block ayrıca her position’a bağımsız olarak uygulanan küçük bir MLP taşır; width’i dört kat genişletir ve geri döner, ortada bir GELU vardır. İş bölümü ezberlemeye değer: attention position’lar arasında karıştırır, feed-forward network position içinde hesaplar.

Tam merdiven; her satır üstündeki satıra bir parça ekliyor:

Learned ağırlıklar uniform olanları 14 perplexity puanı yener; bu bölümün tüm argümanı tek satırda budur. Dört head, 16.512 ekstra parametre karşılığında 3 puan daha kazandırır. Aynı head ayrıca yerine geçtiğinde değil eklendiğinde 9 puan daha değerlidir: attention bilgi getirir, bir position’ın ne olduğuna karar vermez.

Şimdi parametrelerin gerçekte nerede durduğu; sadece diyagramı görmüş insanları şaşırtır:

Her transformer block’un üçte ikisi feed-forward network’tür, her scale’de; çünkü attention’da dört $d \times d$ matrisi vardır, MLP’de ise bunun sekizine denk geleni. Bir model ne biliyorsa, onu tutan parametrelerin çoğu per-position MLP’nin içindedir.

LayerNorm Bölüm 6’da kuruldu ve ölçüldü; bu bölüm onu orada bırakıldığı hâliyle kullanıyor. Residual connection’lar orada adlandırıldı ve ablate edildi; burada kuruluyor. Yukarıdaki "eklendi, yerine geçmedi" satırları residual connection’lardır; ortalama için 188, tek head için 9 perplexity puanı değerindedir. LayerNorm⁷ her example’ı feature’ları boyunca normalize eder ve Bölüm 6 burada BatchNorm’un değil onun neden hayatta kaldığını vermişti — batch’e bağımlılık yok, running statistics yok, training ve inference’da aynı, sequence length’e kayıtsız — bunların her biri, tek bir kullanıcı için tek seferde bir token generate ettiğinde gereklilik hâline gelir; Bölüm 13 sonunda oraya varır. 768 parametreye mal olur ve 1,8 perplexity puanı kazandırır.

class Block(nn.Module):
    def forward(self, x):
        x = x + self.att(self.ln1(x))     
        x = x + self.ff(self.ln2(x))      
        return x

Normalization’ın nerede durduğuna bak: her sub-layer’ın input’unda, input’tan output’a residual path hiç normalize edilmeden. Bu pre-norm’dur. 2017 paper’ı tersini yapar, x = LayerNorm(x + Att(x)) — post-norm, LayerNorm’u residual path’in kendisine koyar.

Xiong et al. farkı initialisation’daki gradient üzerinden açıkladı; post-norm network’te gradient depth ile kötü scale olur — original transformer’ın train edebilmek için learning-rate warmup’a ihtiyaç duymasının nedeni buydu.⁸ On iki block, 1000 adım, learning rate $3 \times 10^{-3}$:

gradient norm per block at initialisation, before any step
  pre-norm    block 1 0.0498 ... block 12 0.0657   ratio last/first  1.32
  post-norm   block 1 0.0977 ... block 12 0.1613   ratio last/first  1.65

  pre-norm,  no warmup          perplexity   37.82
  pre-norm,  200-step warmup    perplexity   37.62
  post-norm, no warmup          perplexity  308.05
  post-norm, 200-step warmup    perplexity   37.88

Warmup’sız post-norm sekiz kat daha kötü; warmup’lı post-norm pre-norm ile tam eşleşiyor. Warmup burada genel iyi pratik değildir; normalization’ın belirli bir düzenlemesi için patch’tir ve LayerNorm’u taşımak ona duyulan ihtiyacı kaldırır. 2019’dan beri neredeyse her modelin pre-norm olmasının ve 2017 diyagramının specification değil tarih olarak okunması gerektiğinin nedeni budur.

Position embeddings’i sil ve model yine eğitilir; sadece hiçbir şeyin nerede olduğunu söyleyemez, bu da training failure değil bir symmetry’dir. Attention score’da $t$ ya da $i$’nin kendisi geçmez; bu yüzden input’u permute etmek output’u permute eder: self-attention permutation-equivariant’tır. Ortalama almanın order-blindness’ının daha iyi kılık değiştirmiş hâlidir — causal mask bir miktar sıra geri getirir, çünkü her position farklı bir prefix görür; ama bir prefix’in içinde tüm sıralamalar aynıdır.

Position eklemenin dört yolu, 64-token window’larda eğitildi ve gördükleri uzunluğun ötesinde 64, 128 ve 256’da değerlendirildi:

Learned absolute embeddings — position başına bir vector, token’a eklenir — eğitim uzunluğunda kazanır ve sonra uçurumdan düşer; çünkü position 100 hiç batch içinde bulunmamıştır ve embedding’i başladığı random vector olarak kalmıştır. Sinusoids, original seçim, learned değil computed’dır; geometrik aralıklı frekanslarda sine ve cosine’lardan gelir. 2017 paper’ı bunun extrapolate edeceğini umdu ve tablo etmeyeceğini söylüyor — function position 200’de tanımlıdır, ama model onu orada okumayı hiç öğrenmedi. RoPE⁹ hiçbir şey eklemez; bunun yerine query ve key’i position ile orantılı bir angle kadar, iki boyutlu dilimlerde döndürür. Dot product’ın iki tarafını da eşit döndürmek sonucu değiştirmediği için score sonunda yalnızca $t - i$’ye bağlı olur; position bedavadan relative hâle gelir ve tükenecek bir tablo yoktur. Bozulur, ama kademeli bozulur. ALiBi¹⁰ buradaki en basit ve en tuhaf sonuçtur: distance ile orantılı, head başına farklı slope’a sahip score üzerinde linear penalty. Window training length’i geçtikçe perplexity’si iyileşir, 44,95’ten 42,49’a; çünkü penalty her distance’ta tanımlıdır ve her head eğitildiği şeyi yapmaya devam eder.

Ders tablodan daha uzun ömürlüdür: bir mimarinin bir şeyi represent edememesi, o aralığı hiç learn etmemiş olmasından farklı bir problemdir; ısıran ikinci problemdir. Bu aynı zamanda her "context’i 128K’ya genişlettik" duyurusunun arkasındaki mekaniktir — bunlar neredeyse her zaman rotary encoding’in re-scaling’leridir ve Bölüm 16’nın context limitinin yok olmak yerine yer değiştirdiğini söylemesinin nedeni de budur.

Dropout da aynı şekilde miras alınır: softmax’ten sonra attention weights üzerinde, residual addition’dan önce her sub-layer output’unda ve embedding toplamında görünür; Bölüm 6’nın tarif ettiği şeyi aynen yapar. Büyük pretraining run’larında çoğu zaman sıfıra ayarlanır, çünkü her token’ı bir kez gören bir model overfit edecek konumda değildir.

Layer’daki iki tensor $n \times n$ shape’ine sahiptir; burada $n$ token sayısıdır: score’lar ve softmax sonrası ağırlıklar. Geri kalan her şey — her projection, tüm MLP — $n$ içinde linear’dır.

Bir attention layer, 512 wide, 8 heads, batch of one, float32, laptop GPU üzerinde. İki millisecond sütununu yalnızca oranları için oku: bunlar ısınınca 1.785 MHz’den 300 MHz altına throttling yapan 8 GB laptop kartındaki wall clock değerleri; bu yüzden aynı kodun soğuk bir run’ı yedi ila on kat hızlı, meşgul bir run’ı daha da yavaş döner. Megabyte sütunları allocator byte count’larıdır ve değişmez.

  tokens   ms total    ms x4   ms projections   attn matrix MB    peak MB    MB x4
     128      2.246        -            1.324              0.5       14.6        -
     256      2.855     1.27            2.113              2.0       19.2     1.31
     512      5.761     2.02            3.105              8.0       34.4     1.79
    1024     16.414     2.85            4.008             32.0       89.1     2.59
    2048     51.573     3.14            9.989            128.0      296.1     3.32
    4096    225.432     4.37           20.176            512.0     1100.1     3.72
    8192    832.838     3.69           40.106           2048.0     4300.1     3.91
   16384   OUT OF MEMORY                                 8192.0

fitted exponent (log-log slope, last four rows):  time ~ n^1.91   memory ~ n^1.87

x4 sütunları bir üst satıra oranı gösterir ve $n$’in ikiye katlanması hem time hem memory için tam olarak 4’e yakınsar — son adımda teorik 4’e karşı 3,91. Projections sütunu control’dür: 1024 token’da 4,0 ms’den 8192’de 40,1 ms’ye, sekiz kat için on kat. İlan edildiği gibi linear.

Sonra son satır. Bir attention layer, tek sequence, etrafında model yok, 16.384 token’da 8 GB GPU’da memory’den düşüyor — tek başına score matrisi 8 GB olurdu: 8 head çarpı 16.384 çarpı 16.384 çarpı 4 byte. Model değil; tek bir layer’daki tek bir intermediate tensor.

Bu, sonraki üç bölümün altındaki fiziksel gerçektir. Bir context window’un neden bir limiti olduğunu açıklar; Bölüm 16 bunu fiyata dönüştürür. FlashAttention’ın neden var olduğunu açıklar: matrisi hiç depolamadan, aynı sonucu tile’lar içinde hesaplamak — hız optimizasyonu olmadan önce memory optimizasyonu.¹¹ Ve uzun bir prompt’un fiyatının aritmetiğidir; Bölüm 24 bunu bir agent loop içinde öder — o bölümün diğer bulgusundan ayrı bir mesele: modelin uzun context’i ayrıca daha kötü kullandığı, bunu ölçtüğü ve suçu bu formüle atmayı reddettiği bulgusu.

2017 paper’ı bir encoder-decoder tarif eder: kaynağı unmasked attention ile okuyan bir stack, hedefi causally generate eden ikinci bir stack ve ortada decoder query’lerinin encoder key’leriyle buluştuğu üçüncü bir attention türü. Input ve output’un iki sequence olduğu çeviri için bu doğrudur.

Kazanan, decoder-only yarısı oldu — tek stack, baştan sona causal, input ve output aynı sequence içinde — ve nedeni elegancy değil. "Bir sonraki token’ı tahmin et" herhangi bir text üzerinde çalışır; bu yüzden training set parallel corpus yerine internettir ve her şey o tek task’e dönüşür: translation, source sonra target içeren bir document’tır; question ve answer bir document’tır; ortasında tool call olan conversation bir document’tır. Bölüm 11 sonuncusunun nasıl üretildiğiyle ilgilidir. Encoder’lar kaybolmadı — biri tüm input’u aynı anda görür; bir text’i devam ettirmek yerine represent etmek istediğinde aradığın şey budur. Bölüm 19’daki retrieval embeddings’in chat yapan modelden değil encoder’lardan gelmesinin nedeni de budur.

Block tanımlandığında model boyutu aritmetiktir. Block başına, width $d$ ve dört kat expansion ile: GPT-2’de olduğu gibi dört tanesinde de bias olan $W_q, W_k, W_v, W_o$ için $4d^2 + 4d$ — yukarıdaki tablo bunların üçünde bias’ı bırakır, bu yüzden $d = 768$’te block başına 2.304 daha azdır; MLP için $8d^2 + 5d$; iki LayerNorm için $4d$ — $12d^2 + 13d$, artı $V \times d$’lik token table ve absolute positions için $n_{\text{ctx}} \times d$. GPT-2 small şekli için — $d = 768$, 12 block, 50.257 vocabulary, 1024 context, output layer embedding weights’i paylaşıyor:

  token embeddings     50,257 x 768 = 38,597,376
  position embeddings   1,024 x 768 =    786,432
  one block                             7,087,872
  12 blocks                            85,054,464
  final LayerNorm         2 x 768 =        1,536
  total (weights tied)                124,439,808

Bu, o modelin yayımlanan boyutudur. Formül approximation değil; modelin kendisidir. Ayrıca küçük bir modelin neredeyse üçte birinin embedding table olduğunu not et; vocabulary size’ın preprocessing değil architectural decision olmasının nedeni budur — Bölüm 7’nin kurduğu trade-off.

Perplexity bir corpus hakkında sayıdır. Bir head’in ne yaptığı başka bir sorudur ve bir megabyte Shakespeare üzerinde eğitilmiş bir model bunun için yanlış enstrümandır: 500.000 parametreli bir modelin attention map’i hakkında dürüstçe söylenecek şey, çoğunlukla yorumlanabilir olmadığıdır. O hâlde: sorunun doğru cevabı olan bir dil.

Klasik örnek the animal did not cross the street because it was too tired cümlesidir; burada it animal’dır. Buna karşılık …because it was too wet cümlesinde tek bir kelime referent’i street’e taşır. Bunlar Winograd schemas’tır¹⁴ — biri dışında aynı sentence pair’leri; o tek kelime bir pronoun’un neye refer ettiğine karar verir.

Bunlar ayrıca hileyle çözülebilir; tutorial’ların atladığı kısım budur. İki candidate bir animal ve bir place ise, tired ve wet referent’i category ile belirler; yalnızca hangi kelimelerin mevcut olduğunu bilen bir model, order hakkında hiçbir şey bilmeden doğru yapar. Task’in bu version’ında, held-out animal/place pair’leriyle ölçülünce:

uniform causal average           held-out referent accuracy 100.0 %
one transformer block            held-out referent accuracy  91.7 %

Bag of words transformer’ı yener. Bu sentence üzerine kurulan herhangi bir demonstration, attention hakkında hiçbir şey kanıtlamaz.

O yüzden deliği kapat: iki candidate’ı da on altı noun’dan oluşan tek bir pool’dan çek; ikisi de iki slot’un herhangi birinde görünebilsin. Adjective’leri de category yerine role ile böl — dördü it’i crosser yapar (tired, scared, slow, weak), dördü crossed yapar (wet, wide, busy, steep).

the {x} did not cross the {y} because it was too {adj} , so the {ref} waited .

Ordinary next-token predictor olarak eğit, tek position’ı score’la — so the sonrasındaki kelime — ve held-out set’i ters sırası training’de bulunan noun pair’lerinden kur; böylece hangi iki noun’un mevcut olduğunu bilen ama hangisinin önce geldiğini bilmeyen her şey geriye doğru cevap vermek zorunda kalır.

Mevcut iki noun arasında chance %50’dir. Uniform average %27,9’a iner ve pair’in yanlış noun’u ile tam olarak zamanın yarısında cevap verir — üç bölüm önce shuffle test’in predicted ettiği gibi, hangi kelimelerin orada olduğunu bilen ama order hakkında hiçbir şey bilmeyen bir şeyin imzası.

Şimdi map: referent’i adlandırması gereken position’daki attention, her block’un dört head’i üzerinden ortalanmış, tek kelimeyle farklılaşan iki sentence için. Uniform average, görünen on beş token’ın her birine 0,067 koyardı.

the animal did not cross the street because it was too tired , so the animal waited .
  blk 1  the:0.00 animal:0.70 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.06
         because:0.00 it:0.00 was:0.00 too:0.00 tired:0.00 ,:0.05 so:0.00 the:0.19
  blk 2  the:0.00 animal:0.00 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.00
         because:0.00 it:0.00 was:0.00 too:0.00 tired:1.00 ,:0.00 so:0.00 the:0.00

the animal did not cross the street because it was too wet , so the street waited .
  blk 1  the:0.00 animal:0.70 did:0.00 not:0.00 cross:0.00 the:0.00 street:0.06
         because:0.00 it:0.00 was:0.00 too:0.00   wet:0.00 ,:0.05 so:0.00 the:0.19
  blk 2  the:0.00 animal:0.00 did:0.00 not:0.00 cross:0.03 the:0.00 street:0.49
         because:0.00 it:0.00 was:0.00 too:0.20   wet:0.03 ,:0.00 so:0.00 the:0.25

Block 1 iki sentence’ta da aynıdır — adjective ne olursa olsun first noun üzerinde 0,70. Bu bir failure değil proof’tur: ilk layer’da bir position’daki query, o position’ın kendi token’ının ve index’inin function’ıdır; position 14’teki the iki sentence’ta da aynı token’dır. First-layer head, henüz fetch etmediği bir kelimeye condition edemez. Bu yüzden block 1 elindeki tek faydalı şeyi yapar ve first noun’u ileri taşır.

Block 2 sentence’ların ayrıldığı yerdir ve sekiz adjective’in tümünde aynı satır modelin bulduğu rule’u gösterir:

Crosser-adjective için ikinci block tüm ağırlığını adjective üzerine harcar; çünkü answer residual stream’de zaten vardır — block 1 onu oraya koymuştur — ve tek gereken confirmation’dır. Crossed-adjective için gidip diğer noun’u fetch eder. Bu iki hop’lu bir circuit’tir: bir head candidate’ı ileri taşır, sonraki layer’daki bir head onu tutup tutmamaya karar veren token’ı okur. Layer’lar arası composition mekanizmadır; bir block’un %92,7’ye, ikisinin %100’e ulaşmasının nedeni budur.

Bu aynı zamanda gerçek modellerde en iyi belgelenmiş circuit’in şeklidir. Induction heads — önceki-token head’in, sonraki layer’da [A][B] … [A] → [B] pattern’ini tamamlayan bir head’i beslemesi — Anthropic’in interpretability çalışmasının in-context learning’in büyük bir kısmının arkasında tanımladığı şeydir ve pretraining sırasında belirlenebilir bir anda oluşurlar. Bu bölüm o analize kalkışmıyor: iki paper da references’ta verilerek devrediliyor, çünkü gerçek bir modelden circuit okumak bir araştırma alanıdır, bir section değil.

Son olarak implementation. Yukarıdaki otuz satır, weights’i PyTorch’un kendisinden kopyalanmış hâliyle:

ours vs nn.MultiheadAttention           max |diff| = 1.7881393432617188e-07
ours vs F.scaled_dot_product_attention  max |diff| = 1.7881393432617188e-07

Mean magnitude’ı 0,159 olan output’larda $1.8 \times 10^{-7}$: aynı aritmetik, farklı sırada, float32 precision’da.

Kursun geri kalanındaki her modelin üzerine kurulduğu mimariye sahipsin ve ününden daha küçük: ağırlıkları learned olan bir weighted average, parametrelerin üçte ikisini tutan per-position MLP, iki normalization ve iki addition; stack edilmiş.

Elinde olmayan şey herhangi bir şey bilen bir model; stack etmek tek başına bunu düzeltmeyecek. Bu corpus’ta iki block training perplexity 14,49 ve validation perplexity 40,57’ye ulaşır; bir block’un 18,77 ve 38,07 değerlerine karşı — daha fazla capacity, gördüğü şeyde daha iyi, görmediği şeyde daha kötü; bu, Bölüm 6’nın tablosuna transformer konmuş hâlidir. Bu model ile Bölüm 14’ten 30’a kadar konuşulan modeller arasındaki mesafe architectural değildir. Aynı block’tur, daha çok tekrar edilir, çok daha fazla text üzerinde.

Bu da meseleyi bir accounting problemine çevirir ve accounting göründüğünden tuhaftır. Ne kadar text ve insanlar bunu nereden buluyor? Ne kadar arithmetic ve para harcanmadan önce bunu nasıl estimate edersin? Fixed budget varsa modeli büyütmek mi daha iyi, ona daha fazla data göstermek mi — ve doğru cevap var mı, yoksa yalnızca moda mı? Bölüm 10 üçünü de measurement ile cevaplar ve sorunun en ucuz faydalı biçimine fiyat koyar: bugün, GPT-2 gibi bir modeli sıfırdan train etmenin maliyeti nedir?

Bu materyalin üç açıklaması, kendi amaçları için bundan daha iyidir ve bu bölüm onlarla birlikte okunmak üzere yazıldı. Jay Alammar’ın The Illustrated Transformer’ı, data flow’un şimdiye dek çizilmiş en iyi resmidir. Harvard NLP’nin The Annotated Transformer’ı, 2017 paper’ını satır satır running code ile iç içe verir. Andrej Karpathy’nin Let's build GPT: from scratch, in code, spelled out videosu aynı modeli iki saatte live olarak kurar ve yukarıdaki ablation merdiveni farklı bir corpus üzerinde ölçülen aynı omurgadır. Bu bölümün yalnızca dokunduğu interpretability sorusu için primary sources, Anthropic’in interpretability grubundan Elhage et al., A Mathematical Framework for Transformer Circuits (2021) ve Olsson et al., In-context Learning and Induction Heads (2022)’dir.