ট্রান্সফরমার আর্কিটেকচার

২০১৭ — Google এর 8 জন researcher একটা paper publish করলেন: 'Attention Is All You Need'। RNN, LSTM, convolution — কিছুই দরকার নেই, শুধু attention দিয়েই state-of-the-art translation। এই architecture এর নাম Transformer — যা পরে ChatGPT, BERT, GPT-4, Claude, Gemini — সব কিছুর foundation হবে।

Transformer একটি Encoder-Decoder architecture যা সম্পূর্ণভাবে attention এর উপর ভিত্তি করে গড়া। Encoder N (=6) টা identical layer — প্রতিটায় multi-head self-attention + feed-forward। Decoder ও N টা layer — masked self-attention + encoder-decoder attention + feed-forward। Positional encoding দিয়ে sequence order inject করা হয় (RNN নেই বলে)।

RNN এ word গুলো একটার পর একটা process হয় — slow এবং long dependency দুর্বল। Transformer এ পুরো sentence একসাথে process হয় — প্রতিটা word একসাথে অন্য সব word কে দেখে (parallel)। GPU friendly, fast training, long-range dependency strong। Positional encoding দিয়ে বলা হয় 'কে কোথায় বসা' কারণ attention নিজে order জানে না।

• Google Translate (current production)।
• ChatGPT, GPT-4, Claude, Gemini — সব LLM।
• BERT — search ranking, classification।
• Vision Transformer (ViT) — image classification।
• Whisper — speech recognition।

import torch
import torch.nn as nn

class TransformerBlock(nn.Module):
    def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
        super().__init__()
        self.attn = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout, batch_first=True)
        self.norm1 = nn.LayerNorm(embed_dim)
        self.ff = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim),
        )
        self.norm2 = nn.LayerNorm(embed_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        attn_out, _ = self.attn(x, x, x, attn_mask=mask)
        x = self.norm1(x + self.dropout(attn_out))
        ff_out = self.ff(x)
        x = self.norm2(x + self.dropout(ff_out))
        return x

class MiniTransformer(nn.Module):
    def __init__(self, vocab_size, embed_dim=64, num_heads=4, num_layers=2, max_len=50):
        super().__init__()
        self.token_emb = nn.Embedding(vocab_size, embed_dim)
        self.pos_emb = nn.Embedding(max_len, embed_dim)
        self.blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads, ff_dim=128) for _ in range(num_layers)
        ])
        self.head = nn.Linear(embed_dim, vocab_size)

    def forward(self, x):
        positions = torch.arange(x.size(1), device=x.device).unsqueeze(0)
        h = self.token_emb(x) + self.pos_emb(positions)
        for block in self.blocks:
            h = block(h)
        return self.head(h)

model = MiniTransformer(vocab_size=1000)
dummy = torch.randint(0, 1000, (2, 10))
out = model(dummy)
print("Output:", out.shape)
print("Params:", sum(p.numel() for p in model.parameters()))

• Positional encoding ভুলে যাওয়া — order information হারিয়ে যাবে।
• Residual connection (x + attn) skip করা — deep network train হবে না।
• LayerNorm এর জায়গায় BatchNorm — NLP তে LayerNorm সঠিক।
• Decoder এ causal mask না দিয়ে train — future leak হবে।

1. Sinusoidal positional encoding manually implement করুন।
2. Encoder-only vs Decoder-only vs Encoder-Decoder কখন কোনটা — note করুন।
3. PyTorch এর nn.TransformerEncoder দিয়ে classifier বানান।
4. Attention head এর number বাড়িয়ে effect দেখুন।

• Transformer = pure attention based architecture।
• Parallel processing, GPU friendly, long-range strong।
• Encoder: bidirectional, Decoder: causal masked।
• Positional encoding দিয়ে order inject।
• Modern NLP এর foundation — BERT, GPT, T5 — সব এর উপর।