Self-attention nasıl çalışır? Scaled dot-product attention'ı NumPy ile yazın ve neden sqrt(d_k) ile bölündüğünü açıklayın.

Self-attention, bir dizideki her tokenın diğer tüm tokenlara ne kadar "dikkat" edeceğini öğrenerek bağlama duyarlı temsiller üretir. Her token için üç vektör üretilir: Query (ne arıyorum), Key (neyi temsil ediyorum), Value (taşıdığım bilgi).

Attention(Q, K, V) = softmax(Q·Kᵀ / sqrt(d_k) + mask) · V

import numpy as np

def softmax(x, axis=-1):
    x = x - x.max(axis=axis, keepdims=True)  # sayısal kararlılık
    e = np.exp(x)
    return e / e.sum(axis=axis, keepdims=True)

def attention(Q, K, V, causal=False):
    # Q, K: (n, d_k), V: (n, d_v)
    d_k = Q.shape[-1]
    scores = Q @ K.T / np.sqrt(d_k)              # (n, n)
    if causal:
        n = scores.shape[0]
        mask = np.triu(np.ones((n, n), dtype=bool), k=1)
        scores = np.where(mask, -1e9, scores)    # gelecekteki tokenları gizle
    weights = softmax(scores, axis=-1)           # her satırın toplamı 1
    return weights @ V, weights

n, d = 4, 8
X = np.random.randn(n, d)
Wq, Wk, Wv = (np.random.randn(d, d) for _ in range(3))
out, w = attention(X @ Wq, X @ Wk, X @ Wv, causal=True)

Neden sqrt(d_k)?

Q ve K'nin bileşenleri sıfır ortalama ve birim varyanslıysa, nokta çarpımlarının varyansı d_k olur. d_k büyüdükçe (örneğin 128) skorlar çok büyür, softmax neredeyse one-hot hale gelir ve doyar. Bu durumda gradyanlar çok küçülür. sqrt(d_k) ile bölmek varyansı tekrar 1'e çeker.

Multi-head attention

Q, K, V h farklı alt uzaya projekte edilir, her head ayrı attention hesaplar, sonuçlar birleştirilip lineer bir katmandan geçirilir. Farklı head'ler farklı ilişki türlerini (sözdizimi, uzak referans vb.) öğrenebilir.

Karmaşıklık

Zaman karmaşıklığı O(n²·d), attention matrisi için bellek O(n²)'dir. Uzun bağlam için FlashAttention (tiling ile n×n matrisi HBM'de hiç oluşturmadan hesaplar, belleği O(n)'e indirir, hesaplama yine O(n²) ama IO açısından verimlidir ve sonuç birebir aynıdır), sliding window, GQA/MQA gibi teknikler kullanılır.