Salt la conținut

Modelul GPT

IntermediarLectură: 4 min

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).

Episodul 5Modelul GPT (Transformer) de la zero, în PyTorchcapitolul „Modelul, de la tokenuri la scoruri”
model.py
def pick_device():
if torch.cuda.is_available():
return "cuda"
if torch.backends.mps.is_available():
return "mps"
return "cpu"
@dataclass
class 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ărimeCâmpValoare
Mărimea vocabularuluivocab_size10.000
Fereastra de contextblock_size256 de tokenuri
Numărul de blocurin_layer6
Capete de atențien_head6
Dimensiunea modeluluin_embd384, adică 6 capete de câte 64
Probabilitatea de dropoutdropout0,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.

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.

model.py
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
GELU⁡(x)=x⋅Φ(x)=x2(1+erf⁡x2)\operatorname{GELU}(x) = x \cdot \Phi(x) = \frac{x}{2}\left(1 + \operatorname{erf}\frac{x}{\sqrt{2}}\right)

unde Φ(x)\Phi(x) este probabilitatea ca o variabilă cu distribuție normală standard să fie cel mult xx, iar erf⁡\operatorname{erf} 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.

model.py
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 x

Este 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ă.

model.py
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 idx

Metoda forward urmează pașii obișnuiți ai unui decodor Transformer.

  1. 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.
  2. 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).
  3. Normalizarea finală și proiecția pregătesc ieșirea. După o ultimă normalizare pe strat, lm_head produce, pentru fiecare poziție, câte un scor nenormalizat (logit) pentru fiecare dintre cele 10.000 de tokenuri.
  4. 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 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 dimensiune
tokens = vocab_size * n_embd
positions = block_size * n_embd
attention = 4 * linear(n_embd, n_embd) # q, k, v și o
mlp = 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.

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.

model.py
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}")
Terminal window
python model.py

Rezultatul de mai jos vine din seria video a laboratorului.

reprezentări: 3,938,304 | blocuri: 10,646,784 | total: 14,585,856 parametri
intrare (4, 256) -> scoruri (4, 256, 10000)
pierderea la început: 9.276, iar ln(10,000) = 9.210

Reprezentă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 ln⁡10.000≈9,21\ln 10.000 \approx 9{,}21, 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.