Modelul GPT
Modelul laboratorului este un Transformer doar cu decodor (decoder-only Transformer), forma folosită de modelele GPT. Componentele sunt toate cele din GPT-2, publicat de OpenAI în 2019: reprezentări învățate ale pozițiilor, normalizare pe strat, atenție cu capete multiple (multi-head) și o rețea feed-forward cu funcția GELU. Pagina Arhitectura Transformer descrie variantele care le-au înlocuit în modelele actuale, de exemplu RMSNorm, RoPE și SwiGLU. Variantele clasice sunt mai ușor de urmărit, iar la această mărime diferența de calitate este mică.
Tot modelul se află în fișierul model.py. Stratul de atenție, CausalSelfAttention, a fost scris și verificat pe pagina anterioară. Pe această pagină construim restul modelului în jurul stratului de atenție.
La redare, playerul se încarcă de pe YouTube (detalii).
Configurația
Secțiune intitulată „Configurația”def pick_device(): if torch.cuda.is_available(): return "cuda" if torch.backends.mps.is_available(): return "mps" return "cpu"
@dataclassclass GPTConfig: vocab_size: int = 10_000 block_size: int = 256 n_layer: int = 6 n_head: int = 6 n_embd: int = 384 dropout: float = 0.1 bias: bool = True| Mărime | Câmp | Valoare |
|---|---|---|
| Mărimea vocabularului | vocab_size | 10.000 |
| Fereastra de context | block_size | 256 de tokenuri |
| Numărul de blocuri | n_layer | 6 |
| Capete de atenție | n_head | 6 |
| Dimensiunea modelului | n_embd | 384, adică 6 capete de câte 64 |
| Probabilitatea de dropout | dropout | 0,1 |
Dropout-ul pune la zero, la întâmplare, 10% din valori la fiecare pas de antrenare. Modelul nu se poate baza pe nicio valoare anume, așa că învață reprezentări care nu depind de câteva valori izolate și memorează mai greu datele de antrenare. La generare, dropout-ul este oprit.
Funcția pick_device caută întâi o placă grafică NVIDIA (CUDA), apoi procesorul grafic al unui cip Apple Silicon (MPS). Dacă nu găsește niciuna, folosește procesorul obișnuit.
Rețeaua feed-forward și GELU
Secțiune intitulată „Rețeaua feed-forward și GELU”După atenție, fiecare token trece separat printr-o rețea feed-forward cu un strat ascuns de 4 ori mai larg, de 1.536 de neuroni.
def gelu(x): return 0.5 * x * (1.0 + torch.erf(x / math.sqrt(2.0)))
class MLP(nn.Module): def __init__(self, config): super().__init__() self.up_proj = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias) self.down_proj = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias) self.dropout = nn.Dropout(config.dropout)
def forward(self, x): return self.dropout(self.down_proj(gelu(self.up_proj(x))))Funcția de activare este GELU (Gaussian error linear unit), propusă în 2016 de Hendrycks și Gimpel.
Pentru curioșiFormula funcției GELU
unde este probabilitatea ca o variabilă cu distribuție normală standard să fie cel mult , iar este funcția eroare.
PyTorch are deja F.gelu, dar aici funcția este scrisă explicit, ca formula să se vadă în cod. Spre deosebire de ReLU, GELU este netedă și lasă să treacă puțin și din valorile negative apropiate de zero.
import math
def gelu(x): return 0.5 * x * (1.0 + math.erf(x / math.sqrt(2.0)))
for x in [-3, -2, -1, -0.5, 0, 0.5, 1, 2, 3]: print(f"x = {x:>4}: GELU {gelu(x):7.3f}, ReLU {max(0, x):4}")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Un bloc leagă stratul de atenție și rețeaua feed-forward prin conexiuni reziduale, cu normalizarea pe strat înaintea fiecăreia.
class Block(nn.Module): def __init__(self, config): super().__init__() self.attn_norm = nn.LayerNorm(config.n_embd, bias=config.bias) self.attn = CausalSelfAttention(config) self.mlp_norm = nn.LayerNorm(config.n_embd, bias=config.bias) self.mlp = MLP(config)
def forward(self, x): x = x + self.attn(self.attn_norm(x)) x = x + self.mlp(self.mlp_norm(x)) return xEste vorba de schema de pre-normalizare (pre-norm), descrisă în secțiunea despre fluxul rezidual. Atenția și rețeaua feed-forward citesc o versiune normalizată a vectorului x și adaugă rezultatul la vectorul original, fără să-l înlocuiască.
Modelul complet
Secțiune intitulată „Modelul complet”class GPT(nn.Module): def __init__(self, config): super().__init__() self.config = config self.embed_tokens = nn.Embedding(config.vocab_size, config.n_embd) self.embed_positions = nn.Embedding(config.block_size, config.n_embd) self.drop = nn.Dropout(config.dropout) self.blocks = nn.ModuleList([Block(config) for _ in range(config.n_layer)]) self.norm = nn.LayerNorm(config.n_embd, bias=config.bias) self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False) self.embed_tokens.weight = self.lm_head.weight self._init_weights()
def _init_weights(self): for name, module in self.named_modules(): if isinstance(module, (nn.Linear, nn.Embedding)): std = 0.02 if name.endswith(("o_proj", "down_proj")): std /= math.sqrt(2 * self.config.n_layer) nn.init.normal_(module.weight, mean=0.0, std=std) if isinstance(module, nn.Linear) and module.bias is not None: nn.init.zeros_(module.bias)
def num_params(self): return sum(p.numel() for p in self.parameters())
def forward(self, idx, targets=None): B, T = idx.shape pos = torch.arange(T, device=idx.device) x = self.drop(self.embed_tokens(idx) + self.embed_positions(pos)) for block in self.blocks: x = block(x) logits = self.lm_head(self.norm(x)) loss = None if targets is not None: loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1) return logits, loss
@torch.no_grad() def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None, eos_id=None): for _ in range(max_new_tokens): logits, _ = self(idx[:, -self.config.block_size :]) logits = logits[:, -1, :] / temperature if top_k is not None: kth = torch.topk(logits, top_k).values[:, [-1]] logits[logits < kth] = -float("inf") probs = F.softmax(logits, dim=-1) next_id = torch.multinomial(probs, num_samples=1) idx = torch.cat([idx, next_id], dim=1) if eos_id is not None and (next_id == eos_id).all(): break return idxMetoda forward urmează pașii obișnuiți ai unui decodor Transformer.
- Reprezentarea vectorială (embedding) înlocuiește fiecare ID de token cu vectorul corespunzător (
embed_tokens), la care se adună vectorul poziției (embed_positions). Spre deosebire de codificarea pozițională fixă din Transformerul original, din 2017, aici fiecare dintre cele 256 de poziții are o reprezentare învățată. De aceea, modelul nu poate citi mai mult de 256 de tokenuri. - Trecerea prin blocuri duce vectorii, pe rând, prin cele 6 blocuri Transformer, fiecare cu auto-atenție și o rețea feed-forward (MLP).
- Normalizarea finală și proiecția pregătesc ieșirea. După o ultimă normalizare pe strat,
lm_headproduce, pentru fiecare poziție, câte un scor nenormalizat (logit) pentru fiecare dintre cele 10.000 de tokenuri. - Calculul pierderii prin entropie încrucișată are loc doar dacă modelul primește și ținte. Țintele egale cu -1 sunt ignorate, lucru pe care îl folosim la ajustarea fină.
Metoda generate este explicată pe pagina despre generarea textului.
Numărul de parametri
Secțiune intitulată „Numărul de parametri”Numărul de parametri se poate calcula doar din configurație, fără să construim modelul.
vocab_size, block_size, n_layer, n_embd = 10_000, 256, 6, 384
def linear(n_in, n_out): return n_in * n_out + n_out # ponderi și bias
layer_norm = 2 * n_embd # o scalare și un bias pentru fiecare dimensiunetokens = vocab_size * n_embdpositions = block_size * n_embdattention = 4 * linear(n_embd, n_embd) # q, k, v și omlp = linear(n_embd, 4 * n_embd) + linear(4 * n_embd, n_embd)block = 2 * layer_norm + attention + mlp# lm_head nu adaugă nimic: folosește matricea din embed_tokens.total = tokens + positions + n_layer * block + layer_norm
print(f"Tokenuri: {tokens:,}, poziții: {positions:,}")print(f"Un bloc: {block:,} (atenție {attention:,}, feed-forward {mlp:,})")print(f"Total: {total:,} parametri")print(f"Fără ponderi legate ar fi: {total + vocab_size * n_embd:,}")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Rezultatul, 14.585.856 de parametri, este numărul afișat și de model.num_params(). Ponderile legate economisesc 3,84 milioane de parametri, mai mult de o cincime din model.
Verificarea locală
Secțiune intitulată „Verificarea locală”Un model abia creat poate fi verificat înainte de antrenare. Ultima parte a fișierului model.py numără parametrii pe grupuri și trece prin model un lot de 4 secvențe de câte 256 de tokenuri aleatoare.
if __name__ == "__main__": torch.manual_seed(0) config = GPTConfig() model = GPT(config) embeddings = model.embed_tokens.weight.numel() + model.embed_positions.weight.numel() blocks = sum(p.numel() for p in model.blocks.parameters()) print(f"reprezentări: {embeddings:,} | blocuri: {blocks:,} | total: {model.num_params():,} parametri") x = torch.randint(config.vocab_size, (4, config.block_size)) y = torch.randint(config.vocab_size, (4, config.block_size)) logits, loss = model(x, y) print(f"intrare {tuple(x.shape)} -> scoruri {tuple(logits.shape)}") print(f"pierderea la început: {loss.item():.3f}, iar ln({config.vocab_size:,}) = {math.log(config.vocab_size):.3f}")python model.pyRezultatul de mai jos vine din seria video a laboratorului.
reprezentări: 3,938,304 | blocuri: 10,646,784 | total: 14,585,856 parametriintrare (4, 256) -> scoruri (4, 256, 10000)pierderea la început: 9.276, iar ln(10,000) = 9.210Reprezentările tokenurilor și ale pozițiilor au 3.938.304 parametri, iar cele 6 blocuri au 10.646.784. Restul, 768, aparțin normalizării finale. Totalul este cel calculat mai sus doar din configurație.
Ieșirea are câte 10.000 de scoruri pentru fiecare dintre cele 4 × 256 de poziții. Pierderea inițială, pe ținte aleatoare, este apropiată de , adică valoarea pe care o obține un model care dă aceeași probabilitate tuturor tokenurilor. Pagina despre preantrenare explică de ce și cum scade această valoare.
Bibliografie
Secțiune intitulată „Bibliografie”- Ba, J. L., Kiros, J. R. și Hinton, G. E. (2016). Layer Normalization. Preprint arXiv:1607.06450.
- He, K. et al. (2016). Deep Residual Learning for Image Recognition. CVPR 2016.
- Hendrycks, D. și Gimpel, K. (2016). Gaussian Error Linear Units (GELUs). Preprint arXiv:1606.08415. ↩︎
- Press, O. și Wolf, L. (2017). Using the Output Embedding to Improve Language Models. EACL 2017.
- Radford, A. et al. (2018). Improving Language Understanding by Generative Pre-Training. Raport tehnic OpenAI.
- Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. Raport tehnic OpenAI. ↩︎
- Srivastava, N. et al. (2014). Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Journal of Machine Learning Research, 15(56), 1929–1958.
- Vaswani, A. et al. (2017). Attention Is All You Need. NeurIPS 2017.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.