İçeriğe geç

Sequence Modelleme: RNN, LSTM, GRU'dan Encoder-Decoder ve Attention'a Giden Yol

NLP'nin 1990-2017 evrimi: vanilla RNN'in vanishing gradient sorunu, LSTM (Hochreiter 1997) ve GRU çözümü, Seq2Seq (Sutskever 2014), Bahdanau ve Luong attention mekanizmaları, ELMo ile contextual embedding'lerin doğuşu. Bu yolculuk 2017 Transformer'ın zeminini hazırladı.

Şükrü Yusuf KAYA
55 dakikalık okuma
Orta
Sequence Modelleme: RNN, LSTM, GRU'dan Encoder-Decoder ve Attention'a Giden Yol
📜 Transformer öncesi 25 yıl
Bugün herkes 'Attention Is All You Need' diyor ama attention 2014'te zaten vardı; transformer onu sadece standalone bir mimari yaptı. Bu dersi okuduktan sonra 'RNN niye yetmedi, LSTM niye geldi, attention niye gerçekten devrimsel' sorularına matematiksel + tarihsel net cevap verebileceksin. 55 dakika sonra modern LLM'lerin niye böyle yapılandığını çok daha derin anlayacaksın.

Ders Haritası#

  1. Sequence modelleme problemi — ne kadar zor?
  2. Vanilla RNN (1986) — başlangıç ve sınırları
  3. Vanishing gradient matematiksel olarak
  4. LSTM 1997 — gating mechanism çözümü
  5. GRU 2014 — LSTM'in basitleştirilmesi
  6. Word embeddings: word2vec (2013), GloVe (2014)
  7. Seq2Seq 2014 — encoder-decoder paradigma
  8. Bahdanau attention 2014 — fixed bottleneck'i kırma
  9. Luong attention 2015 — varyasyonlar
  10. ELMo 2018 — contextual embedding doğuşu
  11. 2017 öncesi state of NLP — ne kadar hazır?
  12. Transformer'a köprü

1. Sequence Modelleme Problemi#

Bir vector x ∈ ℝ^d sabit boyutlu. Ama dil sequence: değişken uzunluk + token'lar arası bağımlılık.

Klasik yaklaşım (1990 öncesi)#

N-gram models:
P(w_t | w_{t-1}, w_{t-2}, ..., w_{t-n})
. n=2 (bigram), n=3 (trigram), n=5 (5-gram).
Sorunlar:
  • Sparse: çoğu n-gram hiç görünmüyor (smoothing gerekiyor)
  • Local: uzun bağımlılık (örn. cümle başındaki özne) kaçırılıyor
  • Fixed window: n=5'ten ötesi exponential

Niye RNN gerekli?#

İhtiyaç: arbitrary-length sequence'i sabit-boyutlu state'e özetlemek + sequential dependencies'i yakalama.
h_t = f(h_{t-1}, x_t)   # önceki state + güncel input → yeni state
y_t = g(h_t)             # state → output

2. Vanilla RNN (1986)#

Elman 1990, Rumelhart 1986 klasik RNN. Hidden state
h_t
:
ht=tanh⁡(Whhht−1+Wxhxt+bh)h_t = \tanh(W_{hh} h_{t-1} + W_{xh} x_t + b_h) yt=Whyht+byy_t = W_{hy} h_t + b_y

Pratik kullanım (1990-2010)#

  • Character-level language model: Karpathy "char-rnn" 2015 viral oldu
  • Speech recognition: HMM-RNN hybrid
  • Time series: financial prediction, sensor data

Sınırlar#

RNN teorik olarak Turing-complete ama pratikte:
  1. Vanishing gradient: uzun bağımlılık öğrenilemiyor
  2. Exploding gradient: bazen patlamış
  3. Sequential: paralelleştirilemez (her time step öncekine bağlı) → yavaş eğitim
  4. Long context: 50-200 token'ı geçince bilgi kayboluyor

3. Vanishing Gradient — Matematiksel Bakış#

Bir T uzunluğunda sequence için, T'den 1'e gradient akışı:
∂LT∂h1=∂LT∂hT∏t=2T∂ht∂ht−1\frac{\partial L_T}{\partial h_1} = \frac{\partial L_T}{\partial h_T} \prod_{t=2}^{T} \frac{\partial h_t}{\partial h_{t-1}}
∂h_t/∂h_{t-1}
Jacobian. Eigenvalue'ları |λ| < 1 ise çarpım sıfıra gider (vanishing). |λ| > 1 ise infinity'e patlar (exploding).

Pratik etki#

Bir RNN 5 time step öteyi öğrenebilir; 50 step'ten sonra "geçmiş yok" hâlinde. Bu dil için fatal:
"Türkiye'nin ekonomik durumu, çeşitli faktörlere bağlı olarak, göstermektedir."
"Türkiye'nin" subject ile "göstermektedir" verb 10+ token uzakta. Vanilla RNN bunu çoğunlukla yakalayamıyor.

Çözümler#

  1. Gradient clipping (exploding için):
    ||g|| > τ
    ise scale
  2. Orthogonal initialization: weights'leri eigenvalue 1'e yakın init
  3. Identity initialization:
    W = I
    ile başla
  4. LSTM — mimari değişikliği (esas çözüm)

4. LSTM (Long Short-Term Memory) — 1997#

Hochreiter & Schmidhuber 1997 (Hochreiter'ın PhD tezinde). Gating mechanism ile vanishing gradient'i çözen ilk başarılı mimari.

LSTM cell'in 4 kapısı#

Forget gate:   f_t = σ(W_f [h_{t-1}, x_t] + b_f)
Input gate:    i_t = σ(W_i [h_{t-1}, x_t] + b_i)
Candidate:     C̃_t = tanh(W_C [h_{t-1}, x_t] + b_C)
Output gate:   o_t = σ(W_o [h_{t-1}, x_t] + b_o)

Cell state:   C_t = f_t * C_{t-1} + i_t * C̃_t     ← additive!
Hidden state: h_t = o_t * tanh(C_t)

Niye çalışıyor?#

Cell state
C_t
çarpımla değil toplamla güncelleniyor. Backward'da gradient direkt akıyor — vanishing yok.
Forget gate
f_t
decision yapıyor: "önceki cell state'ten neyi tut, neyi unut?" Bu selective memory.

Pratik kullanım#

  • 2014-2017 NLP'nin omurgası
  • Google Translate 2016'ya kadar LSTM-based
  • Speech recognition (Apple Siri, Google Assistant — 2018'e kadar)
  • Time series forecasting

LSTM'in zayıflıkları#

  1. Hâlâ sequential — paralelleştirilemez
  2. Karmaşık — 4 gate, 4× parameter
  3. Uzun context (1000+) hâlâ zor — daha az kötü ama hâlâ sınırlı
  4. Training yavaş
python
import torch
import torch.nn as nn
 
class LSTMCell(nn.Module):
    """Pedagojik LSTM cell — 4 gate"""
    def __init__(self, input_size, hidden_size):
        super().__init__()
        self.hidden_size = hidden_size
        # 4 gate'i tek bir linear ile (faster)
        self.W = nn.Linear(input_size + hidden_size, 4 * hidden_size)
 
    def forward(self, x, state):
        h_prev, c_prev = state
        combined = torch.cat([x, h_prev], dim=-1)
        gates = self.W(combined)
        i, f, g, o = gates.chunk(4, dim=-1)
        i = torch.sigmoid(i)
        f = torch.sigmoid(f)
        g = torch.tanh(g)
        o = torch.sigmoid(o)
        c = f * c_prev + i * g       # cell state — additive!
        h = o * torch.tanh(c)         # hidden state
        return h, (h, c)
 
# Test
cell = LSTMCell(input_size=10, hidden_size=20)
x = torch.randn(4, 10)              # batch=4
h0 = torch.zeros(4, 20)
c0 = torch.zeros(4, 20)
h, (h, c) = cell(x, (h0, c0))
print(f"Output shape: {h.shape}")    # (4, 20)
 
# Production: nn.LSTM kullan
lstm = nn.LSTM(input_size=10, hidden_size=20, num_layers=2, batch_first=True)
seq = torch.randn(4, 50, 10)         # batch=4, seq=50, d=10
out, (h, c) = lstm(seq)
print(f"Sequence output: {out.shape}")  # (4, 50, 20)
LSTM cell'in PyTorch implementasyonu.

5. GRU (Gated Recurrent Unit) — 2014#

Cho et al. 2014. LSTM'in basitleştirilmesi: 4 gate yerine 2.

GRU formülleri#

Reset gate:    r_t = σ(W_r [h_{t-1}, x_t])
Update gate:   z_t = σ(W_z [h_{t-1}, x_t])
Candidate:     h̃_t = tanh(W [r_t * h_{t-1}, x_t])
Hidden state:  h_t = (1 - z_t) * h_{t-1} + z_t * h̃_t

Avantajlar#

  • Daha az parametre (~%30 az)
  • Daha hızlı training
  • Performans LSTM ile çoğu zaman comparable

Dezavantaj#

  • Bazı uzun-bağımlılık görevlerinde LSTM'den hafif geri

Empirik karar#

2015-2017 araştırmaları: LSTM ve GRU dataset ve task'a göre birbiriyle yarışıyor. Pratik bilgelik: önce GRU dene, yetmezse LSTM.

6. Word Embeddings — word2vec, GloVe#

NLP'nin ikinci büyük devrimi: kelimeleri dense vector'lara çevirmek.

Word2Vec (Mikolov 2013)#

Google'dan Tomas Mikolov: Skip-gram ve CBOW modelleri.
Skip-gram: tek kelime → context tahmin et
CBOW: context → tek kelime tahmin et
Eğitim sonunda her kelime için 300-dim vector. Sürpriz: vector aritmetiği anlamlı.
king - man + woman ≈ queen
Paris - France + Italy ≈ Rome
Bu, embedding uzayının manifold yapısının ilk somut kanıtı (Modül 1.10'da gördük).

GloVe (Pennington 2014)#

Stanford'dan: Global Vectors for Word Representation. Word2Vec local context tahmin ederken, GloVe global co-occurrence matrix'inden vector türetiyor. Bazı task'larda hafif iyi.

FastText (Bojanowski 2017, Facebook)#

Sub-word information: bir kelimeyi character n-gram'larına böl, embed et. Türkçe gibi morfolojik dillerde kritik avantaj — out-of-vocabulary problem'ini azaltır.

Bu döneme miras#

  • Pretrained word embeddings standart oldu
  • Embedding matrisi NLP modelinin ilk katmanı
  • Anlam matematik olarak temsil edilebilir
  • Transfer learning kavramı yerleşti — bir görev için eğitilen embedding başka görevde kullanılabilir

7. Seq2Seq — Encoder-Decoder 2014#

Sutskever, Vinyals, Le (Google) — "Sequence to Sequence Learning with Neural Networks", NeurIPS 2014.

Fikir#

Sequence → fixed vector → Sequence. İki LSTM:
  1. Encoder: input sequence'i okur, son hidden state'i tut → "context vector"
  2. Decoder: bu context'ten output sequence üretir
Input: "How are you?"
Encoder LSTM → h_final
Decoder LSTM(h_final) → "Nasılsın?"

Uygulama: Machine Translation#

Klasik istatistiksel MT (phrase-based) 30 yıllık tradition'ı bir buçuk yılda bıraktı. Google 2016'da Google Neural Machine Translation (GNMT) production'a aldı — kalite step-function iyileşti.

Problem: Fixed-length bottleneck#

Tüm input sequence'in bilgisi tek bir context vector'e sıkıştırılıyor. Uzun cümlede information loss kaçınılmaz.
Örnek: 50 kelimelik Türkçe paragrafı 512-d vector'e sıkıştırırken büyük bilgi kaybı.

Çözüm: Attention#

8. Bahdanau Attention — 2014 — Devrim#

Bahdanau, Cho, Bengio — "Neural Machine Translation by Jointly Learning to Align and Translate", ICLR 2015 (preprint 2014).

Fikir#

Decoder her step'te tek bir context vector'e bağlı kalmasın — her input position'a "bakabilsin".

Formülleri#

Encoder her input için hidden state
h_i
üretiyor (concat forward + backward LSTM).
Decoder step
t
'de:
e_{t,i} = a(s_{t-1}, h_i)              # alignment score: decoder state vs encoder state i
α_{t,i} = softmax(e_{t,:})[i]          # attention weight
c_t = Σ_i α_{t,i} * h_i                 # context vector — weighted sum
s_t = LSTM(s_{t-1}, [y_{t-1}, c_t])    # decoder state
y_t = softmax(W s_t)                    # output

Bahdanau alignment fonksiyonu#

a(s, h) = v^T tanh(W_s s + W_h h)      # additive attention
Bu additive attention ya da Bahdanau attention olarak anılır.

Niye devrimsel?#

  1. Fixed bottleneck kalktı: decoder her step'te tüm encoder state'lere bakar
  2. Interpretability:
    α
    matrix'i "translation alignment" gösteriyor
  3. Long sequence handling: input uzunluğu artıkça performance düşmüyor

Görsel kanıt#

Bahdanau paper'ında "alignment matrix"in visualization'ı: Fransızca-İngilizce çeviride doğal kelime hizalaması ortaya çıktı. Modele kimse bunu söylemedi — kendi öğrendi.

9. Luong Attention — 2015 — Varyasyonlar#

Luong, Pham, Manning (Stanford) — "Effective Approaches to Attention-based Neural Machine Translation", EMNLP 2015.

Yenilikler#

  1. Multiplicative attention:
    a(s, h) = s^T W h
    veya
    s^T h
    (dot-product). Additive'tan daha hızlı (matrix mult).
  2. Global vs Local attention:
    • Global: tüm encoder state'lere bakar (Bahdanau gibi)
    • Local: bir window'a sınırlı bakar (compute tasarrufu)

Dot-product attention#

score(s, h) = s^T h          # bias yok, scale yok
Bu, modern transformer attention'ın direkt atası. Vaswani 2017'de "scaled dot-product":
Attention(Q, K, V) = softmax(QK^T / √d) V
Sadece
/√d
eklendi (numerical stability) ve 3 ayrı projection (Q, K, V) ile genelleştirildi.

Pratik etki#

2016-2017 NMT araştırması neredeyse tamamen attention-based oldu. LSTM hâlâ encoder/decoder backbone ama attention vazgeçilmez.

10. ELMo 2018 — Contextual Embedding Doğuşu#

Peters et al. (AI2) — "Deep contextualized word representations", NAACL 2018.

Fikir#

Word2Vec / GloVe kelimenin tek bir embedding'i veriyor — "bank" hem nehir kenarı hem finansal kurum için aynı vector. Yanlış!
ELMo: Bidirectional LSTM language model ile her kelimeye bağlama göre embedding ver.
"I deposit money at the bank"     → bank_embed_1 (finansal)
"She sits on the bank of river"   → bank_embed_2 (nehir)

Sonuçlar#

11 NLP task'ta state-of-the-art. Contextual embeddings kavramını yerleştirdi.

Niye önemli?#

ELMo, pretrain + fine-tune paradigmasının NLP'ye yerleşmesini hazırladı. 2018 sonunda BERT bu fikri transformer ile çok daha güçlü yaptı.

Türkçe için#

ELMo'nun Türkçe versiyonu (bertürk'ten önce) İTÜ ekibi tarafından yapıldı. Morfolojik zenginlik için sub-word ELMo varyasyonları kullanıldı.

11. 2017 Öncesi NLP Durumu#

Transformer'a hemen önce (2017 başı):

Backbone#

  • Bi-LSTM + Attention (encoder ve decoder)
  • Word embedding: word2vec, GloVe, fastText
  • Pretrained features: bazı görevlerde kullanılıyor ama henüz tam paradigma değil

State-of-the-art görevler#

  • NMT: Google GNMT (8-layer LSTM + attention) Türkçe-İngilizce dahil
  • Question Answering: SQuAD benchmark, BiDAF model
  • NER: Bi-LSTM-CRF
  • Sentiment: LSTM + attention

Problemler#

  1. Sequential — eğitim yavaş, paralelleştirilemiyor
  2. Uzun bağımlılık hâlâ tam çözülmedi (50-200 token sweet spot)
  3. Pretrain paradigmasının yetersizliği — task başına ayrı eğit
  4. Transfer learning sınırlı — embeddings dışında

Hazır olan#

  • Attention mekanizması — Bahdanau-Luong matur
  • Encoder-decoder paradigma — yerleşti
  • GPU compute — yeterli
  • Dataset'ler — büyük (WMT translation, Wikipedia)
Eksik olan: tek bir taş daha — "attention'ı standalone bir mimari haline getir" fikri.

12. Transformer'a Köprü#

Haziran 2017, Google Brain ekibi (Vaswani et al.) "Attention Is All You Need" paper'ını yayınladı.

Mesele basit ama radikal#

"RNN/LSTM olmadan, sadece attention ile sequence modelleme yapalım. Paralleştirilebilir, daha hızlı, belki daha iyi."

Mimari#

Encoder: self-attention + FFN (× 6 layer)
Decoder: masked self-attention + cross-attention + FFN (× 6 layer)
3 attention türü:
  1. Encoder self-attention: encoder içi token'lar birbirine bakar
  2. Decoder masked self-attention: decoder içi (causal mask)
  3. Decoder-encoder cross-attention: decoder, encoder output'una bakar (Bahdanau attention'ın direct successor)

Kazanım#

WMT 2014 English-German translation: 28.4 BLEU (önceki SOTA 26.3). Eğitim 8 GPU × 3.5 gün (LSTM 8 GPU × günler).

Sonra#

  • 2018: BERT (encoder-only), GPT-1 (decoder-only) — transformer mimari adoption
  • 2019: GPT-2 (1.5B), XLNet, RoBERTa
  • 2020: GPT-3 (175B), T5, BART
  • 2021: Codex, CLIP, ViT
  • 2022: ChatGPT, AlphaCode, LaMDA
  • 2023-2026: Llama, Claude, Mistral, DeepSeek, GPT-4/5

Felsefi miras#

Vaswani 2017'nin başlığı "Attention Is All You Need" sembolik: önceki 25 yıllık RNN/LSTM/CNN paradigmalarının yetersiz, attention'ın tek başına yeterli olduğu iddiası. Bugünden bakınca doğru çıktı.
Modül 4 ve sonrasında transformer'ı derinleştireceğiz.

13. Mini Egzersizler#

  1. Vanishing gradient hesabı: Vanilla RNN, T=100, Jacobian eigenvalue ortalaması 0.9. T=1'den T=100'e gradient ne kadar küçülür?
  2. LSTM vs GRU karar: Türkçe metin sınıflandırma görevi, dataset 10K örnek. Hangi mimari? Niye?
  3. Bahdanau additive vs Luong dot-product: Hangisi daha hızlı? Hangisi daha expressive? Modern transformer hangisini kullanıyor niye?
  4. Word2vec embedding kalitesi: 'bank' kelimesinin word2vec embeddingi finansal mi nehir mi? Bunu nasıl çözeriz?
  5. 2017 öncesi LSTM-based MT: 1000-token Türkçe paragrafı çevirmek istersek, LSTM-based seq2seq vs attention-augmented seq2seq performans farkı ne?

Bu Derste Neler Öğrendik?#

✓ Sequence modelleme problemi: variable length + dependencies ✓ Vanilla RNN (1986) ve vanishing gradient matematiği ✓ LSTM (1997): gating mechanism, additive cell state ✓ GRU (2014): LSTM'in basitleştirilmesi ✓ Word embeddings: word2vec (2013), GloVe, fastText — anlam matematik olarak ✓ Seq2Seq (2014): encoder-decoder paradigma, fixed bottleneck problemi ✓ Bahdanau attention (2014): additive, devrim — fixed bottleneck'i kırma ✓ Luong attention (2015): multiplicative + local — modern dot-product'ın atası ✓ ELMo (2018): contextual embedding doğuşu ✓ 2017 öncesi NLP: backbone hazır, sadece transformer eksik

Sıradaki Ders#

3.5 — "Attention Is All You Need" Sonrası 8 Yıl: Transformer Devriminin Tam Anatomisi Modül 3'ün son dersi: Vaswani 2017'den 2026'ya transformer'ın evrimi. BERT, GPT, scaling laws, RLHF, multimodal, reasoning model'lar. Modern LLM'in son 8 yıldaki şekillenişi.

Sık Sorulan Sorular

Var ama daralan. (1) **Time series forecasting** (finansal, sensör data): klasik LSTM hâlâ baseline. Foundation time-series models (TimesFM, Chronos) yerine geçiyor ama LSTM hâlâ yaygın. (2) **Embedded / edge devices**: çok küçük model gerekirse, LSTM <100K parameter ile çalışır. (3) **Real-time low-latency streaming** (örn. live transcription): transformer batched, RNN sequential — bazı edge case'lerde RNN avantajlı. (4) **Reinforcement learning** policy networks: hâlâ LSTM yaygın. Modern frontier'da değil ama production'da yer alıyor.

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