İçeriğe geç

Lineer Cebir Refresher: Vektör, Matris, Broadcasting, Einsum — LLM Mühendisinin Matematiksel Dili

Vektör/matris/tensor sezgisi, broadcasting kuralları, dot product, matris çarpımının üç farklı bakış açısı, einsum notasyonu, norm aileleri, attention'da Q@K^T çarpımının matematiksel anatomisi.

Şükrü Yusuf KAYA
38 dakikalık okuma
Başlangıç
Lineer Cebir Refresher: Vektör, Matris, Broadcasting, Einsum — LLM Mühendisinin Matematiksel Dili
📐 Modül 1'e hoş geldin
Sonraki 10 ders boyunca bir LLM mühendisinin günde defalarca kullandığı matematiği inşa edeceğiz. Bu ders refresher değil, inşa. Lineer cebiri 'biliyordum' diyenler bile attention mekanizmasını gerçekten matematiksel olarak yapabildiklerinde 'hımm, demek böyleymiş' diyor. 38 dakika sonra Q @ K^T çarpımının her bit'inin nereden geldiğini bileceksin.

Neden Lineer Cebir? Bir LLM'in İç Bakışı#

Llama 3.1 8B modelinin tek bir forward pass'inde tahminen şu işlem yapılır:
  • ~3 trilyon floating-point operation (3 TFLOPs)
  • Bunun %95'i matris çarpımı (GEMM)
  • Bunun %4'ü element-wise activation (SwiGLU, RMSNorm)
  • Bunun %1'i softmax, embedding lookup, residual ekleme
Yani: LLM'in tamamı, doğru sırada yapılan matris çarpımlarıdır. Lineer cebir bilmeden LLM mühendisliği yapmak, müzik teorisi bilmeden orkestra şefliği yapmak gibi.
Bu derste şu soruları cevaplayacağız:
  1. Tensor nedir? PyTorch
    shape
    'i ile geometrik anlamı arasındaki köprü.
  2. Broadcasting nasıl çalışır? "Shape mismatch" hatalarının kökü.
  3. Matris çarpımının üç bakışı: satır-sütun, doğrusal dönüşüm, lineer kombinasyon.
  4. Einsum: Tek satırda istediğin her tensor işlemini ifade etme.
  5. Norm aileleri: L1, L2, Lp, Frobenius — LoRA, weight decay, gradient clipping hep burada.
  6. Attention'da
    softmax(QK^T / √d) V
    :     her boyutun ne ifade ettiği.

1. Skalerler, Vektörler, Matrisler, Tensorlar#

Skaler (rank-0 tensor): Tek bir sayı.
5
,
-0.3
,
π
. Vektör (rank-1 tensor): Sıralı sayı dizisi.
[1, 2, 3]
. Matris (rank-2 tensor): Sayıların 2D tablosu.
[[1,2],[3,4]]
. Tensor (rank-n tensor): n boyutlu sayı dizisi. LLM'lerde sıkça rank-3 ve rank-4 tensorlarla çalışırsın.

LLM'de tipik shape'ler#

TensorShapeAnlamı
Embedding tablosu
(vocab_size, d_model)
Her token için bir vektör
Bir batch input id
(batch, seq_len)
Batch'teki her cümle için token id'leri
Hidden states
(batch, seq_len, d_model)
Her batch × token × özellik
Attention scores
(batch, heads, seq_len, seq_len)
Her batch × kafa × token-token
LoRA matrisi A
(rank, d_in)
Düşük-rank açma
LoRA matrisi B
(d_out, rank)
Düşük-rank kapatma
d_model = 4096
(Llama 3 8B için),
heads = 32
. Toplam parametre sayısı bu shape'lerin çarpımıyla hesaplanır.
python
import torch
 
# Skaler
s = torch.tensor(3.14)
print(s.shape)            # torch.Size([])  — boş
 
# Vektör (rank-1)
v = torch.tensor([1.0, 2.0, 3.0])
print(v.shape)            # torch.Size([3])
 
# Matris (rank-2)
M = torch.tensor([[1., 2.], [3., 4.], [5., 6.]])
print(M.shape)            # torch.Size([3, 2])
 
# Rank-3 tensor — bir mini-batch hidden state
B, T, d = 4, 128, 4096
h = torch.randn(B, T, d)
print(h.shape)            # torch.Size([4, 128, 4096])
 
# Bellek boyutu
print(f"{h.numel() * 4 / 1024**2:.2f} MB (fp32)")  # ~8 MB
print(f"{h.numel() * 2 / 1024**2:.2f} MB (bf16)")  # ~4 MB
PyTorch tensor'larının shape ve bellek hesabı.
🧠 Shape disiplini — Karpathy ipucu
Bir bug'ı %80 hızlandıran tek alışkanlık: kod yazarken yorumda shape belirt.
# (B, T, d)
veya
# x: [B, T, d] -> [B, T, vocab]
. PyTorch'un 'silent broadcasting' hatalarının çoğunu bu önler. İlerde
einops.rearrange
ile bunu daha da güçlendireceğiz.

2. Broadcasting — "Shape Mismatch" Hatalarının Anatomisi#

PyTorch ve NumPy, farklı shape'li tensorları otomatik genişletip element-wise işlem yapmana izin verir. Buna broadcasting denir.

Broadcasting kuralları (sağdan başlayarak hizala)#

İki shape'i karşılaştır:
  1. Sağdan eşle her boyutu.
  2. Boyutlar eşit ise → OK.
  3. Boyutlardan biri 1 ise → 1 olan diğer tarafa "genişler" (kopyalanmadan, view).
  4. Eksik boyut varsa → 1 ile doldurulmuş kabul edilir.
  5. Hiçbiri eşleşmiyorsa →
    RuntimeError
    .
Örnek 1:
(3, 4) + (4,)
→ ✓
A: (3, 4)
B:    (4)   → (1, 4) → (3, 4)
Örnek 2:
(3, 4) + (3,)
→ ✗ (sağdan eşle: 4 ≠ 3) Çözüm:
B.unsqueeze(1)
→
(3, 1)
→ broadcast
(3, 4)
.
Örnek 3:
(B, T, d) + (d,)
→ ✓ (örn. bias eklemek)
A: (B, T, d)
B:        (d) → (1, 1, d) → (B, T, d)
python
import torch
 
# (B, T, d) + (d,) — RoPE veya bias ekleme
B, T, d = 4, 8, 16
hidden = torch.randn(B, T, d)
bias = torch.randn(d)
out = hidden + bias                  # otomatik broadcast (1,1,d) -> (B,T,d)
print(out.shape)                     # (4, 8, 16)
 
# (B, T, d) + (T, d) — position embedding (her batch için aynı pos enc)
pos = torch.randn(T, d)
out2 = hidden + pos                  # (1,T,d) -> (B,T,d)
print(out2.shape)                    # (4, 8, 16)
 
# YANLIŞ: (B, T, d) + (B,) → broadcast başarısız
try:
    bad = hidden + torch.randn(B)
except RuntimeError as e:
    print("HATA:", e)
# RuntimeError: The size of tensor a (16) must match the size of tensor b (4)
 
# DOĞRU: explicit unsqueeze
batch_scalar = torch.randn(B)
ok = hidden + batch_scalar.view(B, 1, 1)   # (B,1,1) -> (B,T,d)
print(ok.shape)                       # (4, 8, 16)
Broadcasting'in başarılı ve başarısız örnekleri.
⚠️ Sessiz broadcasting bug'ı
PyTorch (1, T, d) ve (T, 1, d) shape'lerini sessizce (T, T, d)'ye broadcast eder — yani 64 element bekleyen yerde 4096 element gelir. Bu bug çoğu mühendisin defalarca yakalandığı tuzak. Çözüm: shape comment'i + assert + birim test.

3. Dot Product (İç Çarpım) — Üç Bakış#

İki vektörün dot product'ı (iç çarpımı) tek bir sayıdır:
a⋅b=∑i=1naibi\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i b_i
Bu yalın formülün üç önemli yorumu var:

Yorum 1: Cebirsel#

Element-wise çarp, topla.

Yorum 2: Geometrik#

a⋅b=∥a∥∥b∥cos⁡θ\mathbf{a} \cdot \mathbf{b} = \|\mathbf{a}\| \|\mathbf{b}\| \cos\theta
İki vektör arasındaki açıyı ölçer. Aynı yöne bakıyorlarsa pozitif, dik iseler 0, ters yönde iseler negatif. Cosine similarity burada başlar (embedding benzerliği bunun normalize edilmiş hali).

Yorum 3: Projeksiyon#

a
'nın
b
doğrultusundaki gölgesinin uzunluğu (
b
birim vektörse).

LLM'de niye önemli?#

  • Embedding similarity: cosine similarity = dot product (normalize edilmiş)
  • Attention score:
    score_{ij} = q_i · k_j
    — sorgu ve anahtar vektörlerin uyumu
  • Logit: son katmanda
    logit_v = h · W_v
    — gizli state'in vocab vektörüne projeksiyonu
python
import torch
import torch.nn.functional as F
 
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, -1.0, 2.0])
 
# Üç eşdeğer yol
d1 = torch.dot(a, b)                # cebirsel — sadece 1D
d2 = (a * b).sum()                  # element-wise * sonra sum
d3 = a @ b                          # @ operatörü (PyTorch 1D-1D için dot)
print(d1, d2, d3)                   # tensor(8.) hepsi aynı
 
# Geometrik kontrol
cos_theta = F.cosine_similarity(a.unsqueeze(0), b.unsqueeze(0))
mag_product = a.norm() * b.norm()
print(f"Geometric: {cos_theta.item() * mag_product.item():.4f}")  # 8.0000
 
# Attention'da:
# Q: (B, T, d), K: (B, T, d) -> scores: (B, T, T)
B, T, d = 2, 4, 8
Q = torch.randn(B, T, d)
K = torch.randn(B, T, d)
scores = Q @ K.transpose(-2, -1)    # (B, T, T)
print(scores.shape)                  # torch.Size([2, 4, 4])
# Her score[b, i, j] = Q[b, i, :] · K[b, j, :]  (dot product)
Dot product'ın üç yolu + attention bağlamı.

4. Matris Çarpımının Üç Bakışı#

C = A @ B
çarpımı 3 farklı şekilde okunabilir; üçünü de bilmek gerek:
Klasik tanım:
C[i, j]
= i. satır A × j. sütun B'nin dot product'ı.
Cij=∑k=1nAikBkjC_{ij} = \sum_{k=1}^{n} A_{ik} B_{kj}
Sezgi: Her çıktı elementi, bir input satır ve bir weight sütununun ne kadar "uyduğunu" söyler.
LLM örneği: Embedding lookup'tan sonraki ilk linear:
h = x @ W^T
(x: (T, d_in), W: (d_out, d_in)). Her çıktı nörone (j) her token'ın (i) ne kadar ağırlık verdiği.
python
import torch
 
# Shape uyumu: (m, k) @ (k, n) = (m, n)
A = torch.tensor([[1., 2., 3.],
                  [4., 5., 6.]])      # (2, 3)
B = torch.tensor([[7., 8.],
                  [9., 10.],
                  [11., 12.]])         # (3, 2)
C = A @ B                              # (2, 2)
print(C)
# tensor([[ 58.,  64.],
#         [139., 154.]])
 
# Manuel doğrulama: C[0,0] = 1*7 + 2*9 + 3*11 = 58 ✓
 
# Batched matmul — LLM'in günlük işi
B_size, T, d_in, d_out = 4, 16, 64, 128
X = torch.randn(B_size, T, d_in)
W = torch.randn(d_out, d_in)
 
# Linear layer: y = X @ W^T   (PyTorch nn.Linear böyle yapar)
y = X @ W.T                    # (B_size, T, d_out)
print(y.shape)                  # torch.Size([4, 16, 128])
 
# FLOP hesabı: 2 * B * T * d_in * d_out
flops = 2 * B_size * T * d_in * d_out
print(f"FLOPs: {flops/1e9:.3f} GFLOPs")  # 0.001 GFLOPs (küçük)
 
# Llama 8B'de bir tek FFN katmanı için karşılaştır:
B_, T_, d_, ff_ = 1, 4096, 4096, 14336
flops_real = 2 * B_ * T_ * d_ * ff_
print(f"Llama FFN: {flops_real/1e9:.1f} GFLOPs")  # 481 GFLOPs
Matris çarpımı + LLM'deki gerçek FLOP boyutları.
⏱️ Matris çarpımının zaman karmaşıklığı
Naif algoritma: O(m·n·k). 4096×4096 matris × 4096×4096 matris ≈ 137 milyar çarpma — ama H100 GPU bunu ~3 milisaniyede yapıyor (60+ TFLOPS BF16). LLM yavaşlığı çarpımın kendisinden değil; bellek transferi'nden geliyor (Modül 33'te detaylı). Strassen, Coppersmith-Winograd gibi sub-cubic algoritmalar teoride hızlı ama GPU'da pratik değil — GEMM tile-friendly olduğu için naif sıralı O(n^3) bile çok hızlı.

5. Einsum — Tensor Cebrinin İsviçre Çakısı#

torch.einsum
(Einstein summation notation), karmaşık tensor işlemlerini tek satırda ifade etmenin yolu. Bir kez öğrendiğinde, kodun çok daha okunaklı olur.

Notasyon kuralları#

Format:
"input1,input2,...->output"
  • Aynı harf birden çok input'ta → o boyut toplanır (Einstein convention)
  • Yalnızca output'ta olmayan harf → o boyut kaldırılır (sum out)
  • Output'ta da olan harf → o boyut korunur

Klasik örnekler#

İşlemEinsumEşdeğer
Dot product
"i,i->"
(a * b).sum()
Outer product
"i,j->ij"
a[:, None] * b[None, :]
Matris çarpımı
"ik,kj->ij"
A @ B
Transpose
"ij->ji"
A.T
Trace (köşegen toplamı)
"ii->"
torch.trace(A)
Batched matmul
"bik,bkj->bij"
A @ B
(3D batched)
Attention scores
"bhid,bhjd->bhij"
Q @ K.transpose(-2,-1)
Attention output
"bhij,bhjd->bhid"
attn @ V
python
import torch
 
# 1) Dot product
a = torch.tensor([1., 2., 3.])
b = torch.tensor([4., 5., 6.])
print(torch.einsum("i,i->", a, b))    # tensor(32.)
 
# 2) Outer product
out = torch.einsum("i,j->ij", a, b)
print(out)
# tensor([[ 4.,  5.,  6.],
#         [ 8., 10., 12.],
#         [12., 15., 18.]])
 
# 3) Matris çarpımı
A = torch.randn(3, 4)
B = torch.randn(4, 5)
C1 = torch.einsum("ik,kj->ij", A, B)
C2 = A @ B
print(torch.allclose(C1, C2))         # True
 
# 4) Attention scores: (B, H, T, d) Q ile K
B, H, T, d = 2, 8, 16, 64
Q = torch.randn(B, H, T, d)
K = torch.randn(B, H, T, d)
V = torch.randn(B, H, T, d)
 
# Scores: Q @ K^T -> (B, H, T, T)
scores = torch.einsum("bhid,bhjd->bhij", Q, K) / (d ** 0.5)
 
# Softmax over last dim (key dim)
attn = torch.softmax(scores, dim=-1)
 
# Attention output: attn @ V -> (B, H, T, d)
out = torch.einsum("bhij,bhjd->bhid", attn, V)
print(out.shape)                       # torch.Size([2, 8, 16, 64])
 
# Bu üç satır = scaled_dot_product_attention'ın kalbi!
Einsum ile attention mekanizmasını tek satırda kurmak.
💡 Einsum performansı
Einsum syntax güzel ama her zaman en hızlı değil. PyTorch arka planda
@
veya
bmm
'e mapler ama bazı karmaşık desenler optimal değildir. Production'da kritik path'lerde profile et;
einops
(
rearrange
,
reduce
) çoğu zaman daha okunaklı ve aynı hızlı. Einsum'u öğrenmek için kullan, prod'da gerekirse
@
ya da
torch.compile
'a dönüştür.

6. Norm Aileleri — Vektör Büyüklüğünün Çeşitleri#

Bir vektörün norm'u, o vektörün "büyüklüğü"dür. Tek bir tanım yok; farklı normlar farklı geometrileri verir.

Önemli normlar#

L1 norm (Manhattan / taxicab): ∥x∥1=∑i∣xi∣\|\mathbf{x}\|_1 = \sum_{i} |x_i| Mutlak değer toplamı. Köşeli, "L-şeklinde" mesafe.
L2 norm (Euclidean): ∥x∥2=∑ixi2\|\mathbf{x}\|_2 = \sqrt{\sum_{i} x_i^2} Pisagor uzaklığı. En yaygın.
Lp norm (genel): ∥x∥p=(∑i∣xi∣p)1/p\|\mathbf{x}\|_p = \left(\sum_{i} |x_i|^p\right)^{1/p}
L∞ norm (maks): ∥x∥∞=max⁡i∣xi∣\|\mathbf{x}\|_\infty = \max_i |x_i| En büyük element.
Frobenius norm (matris için): ∥A∥F=∑i,jAij2\|\mathbf{A}\|_F = \sqrt{\sum_{i,j} A_{ij}^2} Matrisi vektör gibi düşünüp L2 al. LLM'de gradient clipping burada kullanılır.

LLM'de niye önemli?#

  • Weight decay (regularization): kayıp fonksiyonuna
    λ ||W||²₂
    eklenir → büyük weight'ler cezalandırılır
  • Gradient clipping:
    ||grad||₂
    belli bir eşiği aşarsa scale et → eğitim stabilitesi
  • Embedding normalization: cosine similarity için L2 normalize
  • LoRA:
    ||ΔW||_F
    küçük olduğu varsayımı düşük-rank decomposition'ı haklı kılar
  • Layer normalization vs RMSNorm: ikisi de L2-based
python
import torch
 
x = torch.tensor([3., -4., 0., 5.])
 
print(torch.norm(x, p=1))      # 12.0 — L1
print(torch.norm(x, p=2))      # 7.0710 — L2 (sqrt(9+16+0+25))
print(torch.norm(x, p=float('inf')))  # 5.0 — L_inf
 
# Matris için Frobenius
W = torch.randn(4, 4)
print(torch.norm(W, p='fro'))  # Frobenius = sqrt(sum of squares)
 
# Pratik 1: Gradient clipping
import torch.nn as nn
model = nn.Linear(10, 5)
# ... loss.backward() ...
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# Tüm gradient'lerin L2 toplam normu 1'i geçerse scale et
 
# Pratik 2: Embedding L2 normalize (cosine similarity için)
emb = torch.randn(100, 128)  # 100 vektör, 128 boyut
emb_norm = emb / emb.norm(dim=-1, keepdim=True)
# Şimdi her satırın L2 normu 1
print(emb_norm.norm(dim=-1)[:5])  # ~1.0
Norm hesaplama + LLM'de pratik kullanım.

7. Bellek Düzeni — Stride, Contiguous, Transpose'un Maliyeti#

Bir tensor sadece "şekil"den ibaret değildir; bellekte nasıl yerleştiği önemli.

Strides (adımlar)#

Bir
(3, 4)
matris bellekte aslında tek bir 1D array —
[m00, m01, m02, m03, m10, m11, ...]
.
stride
ona "şu boyutta ilerlemek için kaç element atla" der.
  • (3, 4)
    contiguous tensor → stride
    (4, 1)
    . (Satırlar arası 4, kolonlar arası 1.)
  • .T
    (transpose) → stride
    (1, 4)
    . Aynı veri, farklı yorumlama.

Neden önemli?#

Bazı operasyonlar contiguous bellek istiyor. Eğer transpose ettiysen,
.contiguous()
çağırmak gerekir (yeni bir kopya çıkarır). Bu, maliyetli: O(n²) bellek + zaman.
.view()
sadece contiguous tensor için çalışır;
.reshape()
gerekirse kopyalar.

LLM'de pratik#

  • x.transpose(-2, -1)
    → strides değişir, kopya yok (hızlı)
  • x.transpose(-2, -1).contiguous()
    → kopya çıkar (yavaş)
  • x.permute(0, 2, 1, 3)
    → multi-head attention'da head boyutunu öne çekme (genelde kopya gerekli)
python
import torch
 
A = torch.arange(12).reshape(3, 4)
print(A)
print(A.stride())                     # (4, 1) — satırlar arası 4, kolonlar 1
print(A.is_contiguous())              # True
 
# Transpose: shape değişti ama bellek aynı
B = A.T
print(B.stride())                     # (1, 4) — şimdi tam tersi
print(B.is_contiguous())              # False — bellekte hâlâ row-major
 
# view() çalışmaz
try:
    B.view(-1)
except RuntimeError as e:
    print("HATA:", e)
# RuntimeError: view size is not compatible with input tensor's size and stride
 
# reshape() veya contiguous() ile düzelt
C = B.contiguous().view(-1)
print(C.stride())                     # (1,)
 
# Multi-head attention'da tipik permute
B, T, H, dh = 2, 8, 4, 16
x = torch.randn(B, T, H, dh)
# Attention için (B, H, T, dh) lazım
x_perm = x.permute(0, 2, 1, 3)
print(x_perm.shape, x_perm.is_contiguous())  # (2, 4, 8, 16), False
# Sonra .contiguous() veya direkt einsum kullan
Stride, contiguous, transpose'un bellek anatomisi.

8. Bütün Bunlar Attention'da Nereye Bağlanıyor?#

Şimdi öğrendiğimizi birleştirelim. Tek bir attention katmanının matematiği:
Attention(Q,K,V)=softmax(QKTdk)V\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V
Adım adım:
  1. X
    (B, T, d) → linear projeksiyon →
    Q, K, V
    (B, T, d) ← 3 matris çarpımı
  2. Q @ K^T
    →
    scores
    (B, T, T) ← batched matrix multiplication (dot product geometric anlamı)
  3. /√d_k
    → element-wise division (broadcasting)
  4. softmax(scores, dim=-1)
    →
    attn
    (B, T, T) ← element-wise exp, sum (broadcast), divide
  5. attn @ V
    →
    output
    (B, T, d) ← batched matmul (lineer kombinasyon bakışı)
Türkçe köşesi: Türkçe bir cümlede her token sözcükten daha küçük (Modül 6 detayında); bu da T'yi büyütür. T büyüdükçe attention'ın bellek tüketimi T² büyür — uzun Türkçe metinlerde RAM patlamasının kökü bu.
python
import torch
import torch.nn.functional as F
 
def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q, K, V: (B, H, T, d_head)
    output:  (B, H, T, d_head)
    """
    d_k = Q.size(-1)
    scores = torch.einsum("bhid,bhjd->bhij", Q, K) / (d_k ** 0.5)
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))
    attn = F.softmax(scores, dim=-1)
    out = torch.einsum("bhij,bhjd->bhid", attn, V)
    return out, attn
 
# Test
B, H, T, d = 2, 4, 8, 16
Q = torch.randn(B, H, T, d)
K = torch.randn(B, H, T, d)
V = torch.randn(B, H, T, d)
out, attn = scaled_dot_product_attention(Q, K, V)
print(out.shape, attn.shape)  # (2,4,8,16) (2,4,8,8)
 
# attn'in rows softmax → her satır toplamı 1
print(attn.sum(dim=-1)[0, 0])  # ~tensor([1., 1., ..., 1.])
 
# PyTorch'un kendi implementasyonuyla karşılaştır
out_torch = F.scaled_dot_product_attention(Q, K, V)
print(torch.allclose(out, out_torch, atol=1e-5))  # True
Lineer cebir bilgisi ile attention'ı sıfırdan yazma.
🎯 Bu kavramları tek bir kursta birleştirdiğin ders bu
Vektör → matris → tensor → broadcasting → einsum → norm → attention. 30 dakika önce 'matris çarpımı' soyut bir kavramdı; şimdi senin için Q ile K'nin uyumunu ölçen geometrik bir işlem. Modül 8'de attention'ı daha derin işleyeceğiz; bu temel olmadan oraya gidemezdik.

9. Mini Egzersizler (yapmadan geçme)#

  1. Shape detective:
    x
    = (4, 8, 16, 16),
    W
    = (16, 32).
    x @ W
    çıktısının shape'i nedir?
  2. Einsum çevirisi:
    torch.einsum("bid,bje->bije", a, b)
    ne yapıyor? (İpucu: rank-3 input'lar, rank-4 output, hiçbir boyut toplanmıyor.)
  3. Broadcasting hatası:
    (B, T, d) * (B, d)
    neden olmuyor? Hangi unsqueeze düzeltir?
  4. LoRA shape: Llama 8B'nin
    q_proj
    matrisi (4096, 4096). Rank-16 LoRA için A ve B matrislerinin shape'i ne? Parametre sayısında ne kadar tasarruf?
  5. Frobenius vs L2: Bir (1024, 1024) matrisin Frobenius normunu hesaplamak, onu vektör olarak L2 normunu hesaplamakla aynı mı? Neden?
(Çözümleri aşağıdaki accordion'da.)

Bu Derste Neler Öğrendik?#

✓ Tensor hiyerarşisi: scalar (0) → vector (1) → matrix (2) → tensor (n) ✓ Broadcasting kuralları ve "shape mismatch" tuzakları ✓ Dot product'ın üç bakışı: cebirsel, geometrik (cos θ), projeksiyon ✓ Matris çarpımının üç yorumu: satır-sütun, lineer dönüşüm, lineer kombinasyon ✓ Einsum notasyonu — tensor cebrinin tek satırlık dili ✓ Norm aileleri: L1, L2, Lp, L∞, Frobenius — LoRA, weight decay, grad clipping ✓ Bellek düzeni: stride, contiguous, transpose maliyeti ✓ Attention mekanizması'nın lineer cebir aktarımı

Sıradaki Ders#

1.2 — Matris Ayrıştırmaları: SVD, Eigendecomposition, PCA, LoRA Bağlantısı Bir matrisin "DNA'sını" öğreneceğiz. SVD'nin LoRA'da nasıl saklı olduğunu görecek, PCA'yı SVD ile sıfırdan kuracağız. Embedding compression ve rank truncation pratikleri.

Sık Sorulan Sorular

Hayır, fonksiyonel olarak aynı. `A @ B` Python operatörü ve PyTorch onu doğrudan `torch.matmul(A, B)`'e çevirir. Tek farkı: `matmul`'ün ek `out=` parametresi var (in-place yazma). Pratikte `@` tercih edilir çünkü kod kısalır. NumPy de aynı pattern'i takip ediyor.

Yorumlar & Soru-Cevap

(0)
Yorum yazmak için giriş yap.
Yorumlar yükleniyor...

İlgili İçerikler

Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

LLM Engineer Kimdir? Junior'dan Staff'a Yapay Zekâ Mühendisliği Kariyer Haritası

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Kurs Felsefesi: Neden Bu Yol, Neden Bu Sıra — 8 Aylık Müfredatın İskeleti

Öğrenmeye Başla
Modül 0: Kurs Çerçevesi ve Atölye Kurulumu

Atölye Kurulumu: uv, PyTorch 2.5+, CUDA, WSL2, Mac MPS, Triton, FlashAttention, Nsight

Öğrenmeye Başla