Self-Attention: Bir Kelime Diğerlerine Nasıl Bakar?

Bugün kullandığınız her LLM'in altında tek bir fikir var: her kelimenin, cümledeki bütün diğer kelimelere aynı anda bakıp "senden ne almam gerekiyor?" diye sorması. Bu yazıda o fikri sıfırdan, adım adım ve gerçek rakamlarla kuracağız — sonunda formülü ezberlemiş değil, anlamış olacaksınız.

Şu iki cümleyi okuyun:

Kupa bavula sığmadı çünkü çok büyüktü.
Kupa bavula sığmadı çünkü çok küçüktü.

Birincide büyük olan kupa, ikincide küçük olan bavul. Tek bir sıfat değişti ve cümlenin öznesi bambaşka bir yere kaydı. Siz bunu düşünmeden yaptınız — ama nasıl yaptınız? Cümledeki diğer kelimelere baktınız. "Büyüktü"yü "kupa"ya, "küçüktü"yü "bavul"a bağladınız.

Önce şunu okuyun (isteğe bağlı): Bu yazı bir LLM'in ne olduğunu, model dosyasının içinde ne bulunduğunu ve "eğitim" derken neyin kastedildiğini bildiğinizi varsayıyor. Bunlar sizin için bulanıksa Bir LLM Aslında Nedir? İndirdiğiniz Dosyanın İçinde Ne Var? yazısıyla başlayın — burada geçen token, embedding, parametre ve ağırlık matrisi kavramlarının hepsi orada tek tek kuruluyor.

İşte self-attention (öz-dikkat) tam olarak bu işi yapan matematiksel mekanizmanın adı. Bir kelimenin, diğer kelimelere uzanıp onlardan anlam devşirmesi. Bu yazıda o uzanmanın nasıl bir matris çarpımına dönüştüğünü göreceğiz; hem de her adımda gerçek sayılarla, elle takip edebileceğiniz şekilde. Yazının sonunda scaled dot-product attention formülüne baktığınızda her sembolün orada neden durduğunu bileceksiniz.

1. Neden RNN Yetmedi?

2017 öncesinde dil modellerinin omurgası RNN'lerdi (recurrent neural network — yinelemeli sinir ağı). RNN kelimeleri tek tek, soldan sağa okur. Her adımda bir hidden state (gizli durum) taşır ve o ana kadar okuduğu her şeyi bu tek vektörün içine sıkıştırmaya çalışır.

Sorun burada başlıyor. "Büyüktü" kelimesine gelindiğinde "kupa" beş adım geride kalmıştır ve o beş adım boyunca sinyal defalarca ezilip yeniden yazılmıştır. Bu, literatürde long-term dependency problem (uzun mesafeli bağımlılık problemi) diye geçen klasik bir kusur: gradient'ler geriye doğru yayılırken ya sıfıra eriyor ya da patlıyor, dolayısıyla model uzak bağlantıları öğrenemiyor^[3].

Attention fikri aslında bu yazının kahramanı olan makaleden eskidir. 2014'te Bahdanau, Cho ve Bengio, çeviri yapan bir RNN'in her adımda kaynak cümlenin tamamına bakıp hangi kelimeye ne kadar ağırlık vereceğini öğrenmesini önerdi — attention o zaman RNN'in yanına takılan bir yardımcıydı^[27]. 2017'de gelen sıçrama şuydu: yardımcıyı bırakıp asıl mekanizmayı attıklarında model daha iyi çalışıyordu. Makalenin adı bu yüzden "Attention Is All You Need" — dikkat, tek başına yeterli.

Transformer makalesinin en sevdiğim tablosu bu problemi tek satırda özetliyor. İki kelime arasındaki sinyalin kat etmesi gereken yolu ölçüyorlar — buna maximum path length diyorlar^[1][2]:

RNN'de iki kelime arasındaki mesafe cümle uzadıkça büyüyor. Self-attention'da her zaman bir. Cümlenin ilk kelimesiyle son kelimesi arasında tek bir adım var. Bunun bedeli de tabloda görünüyor: hesap yükü n² ile büyüyor — 12. bölümde bu bedele geri döneceğiz.

2. Önce Kelimeler Sayıya Dönüşüyor

Matematik yapabilmemiz için kelimelerin sayı olması lazım. Her token (metnin model tarafından işlenen en küçük parçası) bir embedding vektörüyle temsil edilir: d tane gerçel sayıdan oluşan bir liste. Bu vektör kelimenin "kimlik kartı" gibidir; benzer anlamlı kelimeler bu uzayda birbirine yakın düşer.

Bu vektörler eğitimde öğrenilir. Kısaca hatırlatalım: model devasa bir metin yığını üzerinde tek bir hedefle koşturulur — sıradaki token'ı tahmin et. Başta bütün sayılar rastgeledir; her yanlış tahmin backpropagation ile geriye taşınır ve her sayıyı doğru cevabı biraz daha olası kılacak yönde milimetrik olarak iter. Bu döngü trilyonlarca token boyunca tekrarlanır. Yani modeldeki hiçbir sayı elle yazılmamıştır; hepsi bu tekrarın tortusudur. Önkoşul yazısında bu süreci adım adım anlatmıştım.

Yazı boyunca üç token'lık minik bir cümleyle çalışacağız: "kedi mindere oturdu". Gerçek modellerde embedding boyutu 512, 4096 ya da daha fazladır; biz elle takip edebilelim diye d = 4 alacağız. Üç vektörü alt alta dizince X girdi matrisi çıkıyor — 3 satır (token sayısı), 4 sütun (boyut).

3. Q, K, V: Aynı Kelimenin Üç Farklı Kimliği

Şimdi işin can alıcı fikrine geliyoruz. Self-attention, X matrisini üç ayrı matrise projekte eder (yansıtır). Bunun için — az önce tarif ettiğimiz pre-training sırasında öğrenilen — üç ağırlık matrisi kullanılır: W_Q, W_K ve W_V. Bunlar cümleden cümleye değişmez; modelin kalıcı parametreleridir ve gelen her cümleye aynı üç matris uygulanır. Çarpımların sonucunda elimize üç matris geçer:

Benzetmeyi kütüphaneden alalım: elinizdeki arama fişi query, rafların üstündeki etiketler key, kitabın içindeki metin ise value. Fişinizi bütün etiketlerle karşılaştırırsınız, en çok uyanı bulursunuz ve o rafın içeriğini alırsınız. Kritik ayrım şu: eşleşmeyi belirleyen şey key, size aktarılan şey value. Bu ikisi ayrı olduğu için model "kime bakacağım" ile "ne alacağım" sorularını birbirinden bağımsız öğrenebiliyor.

Çarpımın mekaniği de basit: Q'nun ilk satırını bulmak için X'in ilk satırıyla W_Q'nun her sütununun dot product'ını (nokta çarpımını) alırsınız. Aynı işlem her satır için tekrarlanır; üç ağırlık matrisi için de aynı şey yapılır ve Q, K, V hazır olur.

Peki bu W matrisleri nereden geliyor? Kısa cevap: X sizin cümlenizden gelir, W'ler gelmez. X her istekte sıfırdan oluşur ve cevap dönünce atılır; W'ler ise modelin kendisidir — indirdiğiniz dosyanın içinde duran, pre-training'den çıkmış ve donmuş sayılar. Sizin cümlenizden haberleri yoktur, gelen her cümleye aynı üç matris uygulanır. Ölçek fikri versin diye: Llama 3 8B'de bu attention matrisleri modelin 8,03 milyar parametresinin ~1,34 milyarını oluşturuyor, geri kalanın çoğu feed-forward katmanlarında^[28][29]. Önkoşul yazısında bu matrislerin dosyanın neresinde durduğunu, şekillerinin neden öyle olduğunu ve nasıl oluştuklarını şemalarıyla birlikte bulabilirsiniz.

Bundan sonraki adımlar için elimizdeki Q, K ve V şu olsun. (Rakamları takip edilebilir olsun diye seçtim; gerçek bir modelde bu değerler eğitim sonunda kendiliğinden oluşur.)

            Q                        K                        V
kedi     [3, 1, 3, 1]     kedi     [1, 0, 1, 0]     kedi     [2, 0, 1, 0]
mindere  [1, 1, 1, 5]     mindere  [0, 1, 0, 1]     mindere  [0, 2, 0, 1]
oturdu   [3, 2, 3, 1]     oturdu   [1, 1, 0, 0]     oturdu   [1, 1, 2, 2]

4. Skorlar: Her Kelime Herkesle Tanışıyor

Query "ne aradığımı", key "bende ne olduğunu" söylüyorsa, ikisinin ne kadar uyuştuğunu ölçmek için dot product almak yeterli. İki vektör aynı yöne bakıyorsa çarpım büyük, farklı yönlere bakıyorsa küçük ya da negatif çıkar.

Bunu tek tek yapmak yerine tek hamlede hallederiz: Q · K^T. Sonuç 3×3'lük bir skor matrisi. Satırlar soru soran kelimeyi, sütunlar cevap veren kelimeyi temsil eder. Örneğin "kedi" satırındaki "oturdu" sütunu, q_kedi · k_oturdu = 3·1 + 1·1 + 3·0 + 1·0 = 4.

5. Neden √d_k'ye Bölüyoruz?

Formülün en çok "bu da nereden çıktı" dedirten parçası burası. Cevabı aslında makalede tek cümleyle veriliyor: d_k büyüdükçe dot product'lar büyük değerlere ulaşıyor ve softmax'i gradient'lerin son derece küçük olduğu bölgeye itiyor^[1].

Neden büyüyorlar? Basit bir istatistik: query ve key bileşenleri ortalaması 0, varyansı 1 olan bağımsız değişkenler ise, d_k tane çarpımın toplamı olan dot product'ın varyansı d_k olur — yani standart sapması √d_k^[1]. Bunu doğrulamak kolay; rastgele vektörlerle deneyin:

d_k = 512'de skorların ±60, ±100 gibi değerlere savrulması normal. Softmax'e böyle bir sıra verdiğinizde ne olur? En büyük değer 1'e, geri kalan her şey 0'a yapışır. Dağılım tek bir token'ın üstüne çöker, gradient'ler sıfırlanır ve öğrenme durur. √d_k'ye bölmek, skorların standart sapmasını d_k'den bağımsız olarak 1 civarına çeker — ne olursa olsun softmax'in sağlıklı çalıştığı aralıkta kalırsınız^[10][11].

Kendi örneğimizde d_k = 4, yani 2'ye bölüyoruz. Farkı görün:

6. Softmax: Skorları Paylaştırmak

Ölçeklenmiş skorları softmax'ten geçirdiğimizde iki iş birden olur. Önce exponent alınır — farklar keskinleşir; sonra normalize edilir — her satır tam olarak 1'e toplanır. Artık elimizde ham sayılar değil, geçerli bir olasılık dağılımı var. Tam matrisimiz şu:

Son satır güzel: "oturdu" dikkatinin yarısından fazlasını "kedi"ye ayırıyor. Fiil, öznesine uzanmış. Kimse modele "fiiller öznesini bulsun" diye bir kural yazmadı; bu desen tamamen ağırlıkların ürünü.

Bu arada "her satır 1'e toplanmak zorunda" kuralının ilginç bir yan etkisi var: bir kelimenin bakacak anlamlı bir şey bulamadığı durumlarda bile o %100'ü bir yere koyması gerekiyor. Modeller bu artık dikkati genelde cümlenin ilk token'larına boşaltıyor — literatürde attention sink diye geçen olay bu. Sonucu çok pratik: uzun sohbetlerde eski token'ları cache'ten atarken ilk birkaç token'ı (pratikte 4 tanesini) sabit tutmazsanız model çöküyor; sabit tutunca aynı model milyonlarca token'lık akışta ayakta kalabiliyor^[8][9].

7. Çıktı: Value'ların Ağırlıklı Karışımı

Son adım şaşırtıcı derecede sade. Her kelimenin çıktı vektörü, bütün value vektörlerinin — attention ağırlıklarıyla çarpılmış — toplamıdır. "kedi" için:

çıktı(kedi) = 0.665 × v(kedi) + 0.090 × v(mindere) + 0.245 × v(oturdu)
            = 0.665 × [2, 0, 1, 0]
            + 0.090 × [0, 2, 0, 1]
            + 0.245 × [1, 1, 2, 2]
            = [1.575, 0.425, 1.155, 0.579]

Bu vektör artık "kedi"nin yalnız başına anlamı değil; bu cümledeki kedinin anlamı. Kendi kimliğini ağırlıklı olarak koruyor ama içine "oturdu"dan ciddi bir pay karışmış durumda. Aynı işlem her token için yapılır ve self-attention katmanının çıktısı hazır olur: girdiyle aynı şekilde (3×4), ama her satır artık bağlamla zenginleşmiş.

Bütün bu anlattığımız tek satırlık formülün açılımıydı — makalenin meşhur denklemi^[1]:

Attention(Q, K, V) = softmax( Q·Kᵀ / √d_k ) · V

Kodu da aynı ölçüde kısa:

import math
import torch.nn.functional as F

def self_attention(X, Wq, Wk, Wv):
    Q, K, V = X @ Wq, X @ Wk, X @ Wv
    scores  = Q @ K.transpose(-2, -1) / math.sqrt(Q.size(-1))
    weights = F.softmax(scores, dim=-1)      # her satır 1'e toplanır
    return weights @ V, weights

Prod notu: Bu beş satırı öğrenmek için elle yazın, ama gerçek işlerde torch.nn.functional.scaled_dot_product_attention'ı çağırın. Aynı matematiği yapar, ama donanıma göre FlashAttention gibi optimize edilmiş kernel'lere düşer^[23]. Aradaki fark uzun context'lerde katlarla ölçülür — 12. bölümde nedenini göreceğiz.

8. Eksik Parça I: Modelin Kelime Sırasından Haberi Yok

Şimdi rahatsız edici bir gerçeği fark edelim. Yukarıdaki hesabın hiçbir yerinde "kedi birinci token, oturdu üçüncü token" bilgisi geçmedi. Token'ların sırasını değiştirseniz skor matrisinin satır-sütunları yer değiştirir ama içerik aynı kalır. Yani self-attention kelime sırasına kördür.

Bu ciddi bir problem: "Kedi fareyi kovaladı" ile "Fareyi kedi kovaladı" arasındaki farkı kaçırırsınız. Çözüm, konum bilgisini embedding'lere eklemek. Orijinal makale farklı frekanslarda sinüs ve kosinüs fonksiyonları kullandı^[1]. Bugünün modellerinin çoğu ise RoPE (rotary position embedding) kullanıyor: konumu toplamak yerine query ve key vektörlerini konuma bağlı bir açıyla döndürüyor. Böylece iki token'ın dot product'ı doğal olarak aralarındaki göreli mesafeye duyarlı hale geliyor^[6][7].

9. Eksik Parça II: Maskeleme

İkinci eksik parça, cümleyi üreten modellerde (GPT ailesi gibi decoder mimarilerinde) hayati. Bir sonraki kelimeyi tahmin etmeyi öğrenirken model, cevabı ileriden okuyamamalı. Ama kurduğumuz mekanizma herkesi herkese bağlıyor — üçüncü kelime dördüncüye rahatça bakar.

Çözüm basit ve zarif: softmax'ten önce, ileriye bakan hücrelere −∞ yazılır. Exponent alındığında e^−∞ = 0 olur ve o hücreler dağılımdan tamamen silinir; kalan hücreler kendi aralarında yeniden normalize edilir^[12]. Buna causal mask (nedensel maske) denir.

10. Eksik Parça III: Tek Kafa Yetmiyor

Buraya kadar kurduğumuz mekanizmanın bir sınırı var: tek bir attention head aynı anda tek tür ilişkiyi yakalayabiliyor. Ama diller bundan zengin. Bir cümlede aynı anda özne-fiil ilişkisi, sıfat-isim ilişkisi, zamir çözümlemesi ve konu bütünlüğü var. Hepsini tek bir ağırlıklı ortalamaya sıkıştırmak, bütün bu sinyalleri birbirine bulaştırmak demek.

Çözüm multi-head attention: aynı işi h tane paralel kopyada, her biri kendi W_Q, W_K, W_V setiyle yapmak. Orijinal makalede h = 8 ve her head 64 boyutlu çalışıyor (d_model = 512 ÷ 8)^[1]. Dikkat edin: boyut bölünüyor, yani sekiz head'in toplam maliyeti tek büyük head'inkiyle aşağı yukarı aynı. Sonuçlar birleştirilip (concat) son bir W_O matrisiyle karıştırılır^[13][14].

11. Peki Gerçekten Dilbilgisi mi Öğreniyor?

Şimdiye kadar "model özneyi buluyor" gibi cümleler kurdum. Bunun ölçülmüş bir karşılığı var mı? Var. Stanford ve Facebook AI araştırmacılarının BERT'in 144 attention head'ini (12 katman × 12 head) tek tek incelediği çalışma, bazı head'lerin şaşırtıcı derecede temiz dilbilgisi işleri yaptığını gösterdi^[4][5][30]:

Kimse bu modele sözdizimi kuralları öğretmedi; hedefi sadece maskelenmiş kelimeleri tahmin etmekti. Dilbilgisi, bu hedefi tutturmanın en verimli yolu olduğu için kendiliğinden ortaya çıktı.

Ama aynı çalışma bir uyarı da içeriyor: BERT'in 6–10. katmanlardaki dikkatinin yarısından fazlası ayırıcı [SEP] token'ına gidiyor ve yazarlar bunun bir tür "no-op" — yani "bu head'in şu an söyleyecek bir şeyi yok" sinyali olduğunu düşünüyor^[5]. Yani attention haritasındaki her parlak nokta anlamlı değil.

Dikkatli olun — attention bir açıklama değildir. Attention ağırlıklarını "modelin gerekçesi" gibi okumak yaygın ama tartışmalı bir alışkanlık. 2019'da yayımlanan "Attention is not Explanation" çalışması, ağırlıkları ciddi biçimde değiştirip aynı tahmini üretmenin mümkün olduğunu gösterdi^[15]. Aynı yıl gelen "Attention is not not Explanation" cevabı bunun testlere bağlı olduğunu savundu^[16]. Bugünkü dürüst özet şu: attention haritası modelin bilgi akışı hakkında bir ipucudur, kararının kanıtı değil.

12. Faturanın Geldiği Yer: n²

1. bölümdeki tabloya geri dönelim. Self-attention'ın verdiği sabit yol uzunluğunun bedeli, her kelime çiftinin hesaplanması: n token için n² skor. Bu, context uzadıkça acımasızlaşan bir büyüme:

Bu faturayı hafifletmek son yılların en yoğun mühendislik alanı oldu. Üç ana yönü bilmekte fayda var:

FlashAttention — matrisi hiç oluşturma. Tekniğin kilit gözlemi şu: darboğaz çarpma değil, GPU'nun yavaş HBM belleğiyle hızlı SRAM'i arasındaki veri trafiği. FlashAttention devasa n×n matrisini belleğe hiç yazmaz; girdiyi bloklara bölüp softmax'i parça parça, çevrimiçi biçimde hesaplar. Sonuç bitine kadar aynıdır — yaklaşıklık yok — ama bellek ihtiyacı n² yerine doğrusal olur^[17][18].

GQA ve MLA — KV cache'i küçült. Üretim sırasında model her token için key ve value'ları saklar (KV cache) ki her adımda baştan hesaplamasın. Bu cache uzun sohbetlerde modelin kendisinden fazla yer kaplayabiliyor. Grouped-query attention (GQA), birden fazla query head'in aynı key/value çiftini paylaşmasını sağlar; kalite kaybı küçük, cache tasarrufu büyüktür^[19][20]. DeepSeek'in kullandığı multi-head latent attention (MLA) ise key ve value'ları düşük boyutlu bir latent vektöre sıkıştırıp cache'te onu tutar^[21].

Hibrit mimariler — her katmanda tam attention'a gerek yok. 2026'nın en belirgin eğilimi bu: katmanların bir kısmında tam (quadratic) attention, kalanında sliding-window attention ya da Mamba benzeri doğrusal maliyetli state-space katmanları kullanmak. Sistematik karşılaştırmalar, doğru karışımın uzun context'te tam attention'a yakın kalite verirken maliyeti ciddi biçimde düşürdüğünü gösteriyor^[22][24].

Bu üçünün ortak noktasına dikkat edin: hiçbiri self-attention'ın fikrini değiştirmiyor. Query sorar, key cevap verir, value taşınır. Değişen sadece bu işin nerede, hangi hassasiyette ve kaç kelime çifti için yapıldığı.

Kapanış

Başladığımız soruya dönelim: "çok büyüktü" derken neyin büyük olduğunu nereden biliyoruz? Cevap, kelimelerin tek başına anlam taşımaması. Anlam, kelimeler arasında duruyor.

Self-attention'ın yaptığı iş, bu ilişkiyi hesaplanabilir hale getirmekten ibaret. Her kelime bir soru sorar (query), her kelime bir etiket taşır (key), eşleşme oranında içerik aktarılır (value). Dot product benzerliği ölçer, √d_k ölçeği sağlıklı tutar, softmax bir bütçeye çevirir, son çarpım o bütçeyi harcar. Hepsi bu — ve milyarlarca parametre ölçeğinde tekrarlandığında dil modellerinin bizi anlamaya başlamasının sebebi bu oldu.

Peki nereden devam edeceğiz? Üç yol var ve üçü de bu yazının doğal devamı: attention'ı bir Transformer bloğunun içine yerleştirmek (residual bağlantılar, layer norm, feed-forward katman), cross-attention'ı görmek (query bir dizinden, key ve value başka bir dizinden gelirse ne olur — çeviri ve multimodal modellerin temeli), ve KV cache'in prod'da nasıl yönetildiğini incelemek.

Ama en iyisi şu: yukarıdaki beş satırlık fonksiyonu açıp kendi cümlenizle çalıştırın, attention matrisini yazdırın ve satırların gerçekten 1'e toplandığını kendi gözünüzle görün. Formülü okumakla çalıştırmak arasındaki fark, bu konuda sandığınızdan büyük. Görsel anlatım tarafında Jay Alammar'ın "The Illustrated Transformer"ı^[25], satır satır kod tarafında ise Harvard NLP'nin "The Annotated Transformer"ı^[26] bu yazının doğal iki devamı. Modelin geri kalanı — dosyanın içi, parametre bütçesi, üretim döngüsü — merak ediyorsanız önkoşul yazısı orayı anlatıyor. Kolay gelsin!

Kaynaklar