Salt la conținut

Preantrenarea

IntermediarLectură: 7 min

Un model abia creat are ponderi aleatoare și scrie cuvinte fără legătură. În preantrenare (pretraining), modelul citește povești și învață un singur lucru: să prezică următorul token. Nimeni nu îi spune ce este o propoziție sau un personaj. Gramatica, numele personajelor și firul unei povești le învață pe drum, doar pentru că îl ajută să prezică următorul cuvânt.

Codul antrenării se află în fișierul pretrain.py.

La redare, playerul se încarcă de pe YouTube (detalii).

Episodul 6Preantrenarea (pretraining) unui GPT de la zerocapitolul „Predicția următorului token”

Pentru o fereastră de tokenuri x1,…,xTx_1, \ldots, x_T, modelul dă la fiecare poziție tt o distribuție de probabilitate peste vocabular. Pierderea este media logaritmului negativ al probabilității date tokenului care urmează cu adevărat.

Pentru curioșiFuncția de pierdere
L=−1T∑t=1Tlog⁡pθ(xt+1∣x1,…,xt)\mathcal{L} = -\frac{1}{T} \sum_{t=1}^{T} \log p_\theta(x_{t+1} \mid x_1, \ldots, x_t)

unde pθp_\theta este distribuția calculată de model cu parametrii θ\theta.

Această pierdere este entropia încrucișată (cross-entropy), calculată de F.cross_entropy în metoda forward a modelului. Masca cauzală din atenție împiedică poziția tt să vadă tokenul xt+1x_{t+1} pe care trebuie să-l prezică.

Un model netantrenat împarte probabilitatea aproximativ egal între cele 10.000 de tokenuri, deci pornește de la o pierdere în jur de ln⁡10.000≈9,21\ln 10.000 \approx 9{,}21. O mărime mai ușor de interpretat este perplexitatea (perplexity), eLe^{\mathcal{L}}, adică numărul de tokenuri între care modelul ezită, în medie, ca și cum ar alege la întâmplare dintre aceste tokenuri.

import math
vocab_size = 10_000
print(f"Model uniform: pierdere ln({vocab_size}) = {math.log(vocab_size):.3f}")
print()
for loss in [9.21, 5.0, 3.2, 2.25]:
print(f"Pierdere {loss:.2f} -> perplexitate {math.exp(loss):8,.1f}")

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

La fiecare pas, modelul primește un lot (batch) de 48 de ferestre de câte 256 de tokenuri, luate din locuri aleatoare ale fișierului train.bin.

pretrain.py
def get_batch(data, block_size, batch_size, device):
starts = torch.randint(len(data) - block_size - 1, (batch_size,))
x = torch.stack([torch.from_numpy(data[i : i + block_size].astype(np.int64)) for i in starts])
y = torch.stack([torch.from_numpy(data[i + 1 : i + 1 + block_size].astype(np.int64)) for i in starts])
return x.to(device), y.to(device)

Țintele y sunt intrările x deplasate cu o poziție. O singură fereastră conține astfel 256 de exemple de antrenare, câte unul pentru fiecare poziție, toate calculate în paralel. Ferestrele nu țin cont de granițele dintre povești. O fereastră poate începe la mijlocul unei povești și poate trece de <|endoftext|> în următoarea, iar modelul învață și că după acest token începe o poveste nouă.

Mai jos, aceeași funcție este scrisă cu NumPy și rulată pe eșantionul din browser, cu ferestre de doar 8 tokenuri.

import numpy as np
from tokenizer import WordTokenizer, build_vocab
vocab, _ = build_vocab(["povesti.txt"], size=1000)
tokenizer = WordTokenizer(vocab)
with open("povesti.txt", encoding="utf-8") as f:
data = np.array(tokenizer.encode(f.read()), dtype=np.uint16)
def get_batch(data, block_size, batch_size, rng):
starts = rng.integers(len(data) - block_size - 1, size=batch_size)
x = np.stack([data[i : i + block_size].astype(np.int64) for i in starts])
y = np.stack([data[i + 1 : i + 1 + block_size].astype(np.int64) for i in starts])
return x, y
x, y = get_batch(data, block_size=8, batch_size=2, rng=np.random.default_rng(seed=1))
print("x =", x.tolist())
print("y =", y.tolist())
print()
print("Exemplele din prima fereastră:")
for t in range(8):
context = tokenizer.decode(x[0, : t + 1].tolist(), skip_special=False)
print(f" {context!r} -> {tokenizer.id_to_token[y[0, t]]!r}")

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Ponderile sunt actualizate de AdamW, o variantă a coborârii pe gradient folosită de aproape toate modelele de limbaj. Pentru fiecare parametru, Adam păstrează o medie mobilă a gradienților și una a pătratelor gradienților. Pasul urmează direcția mediei, iar mărimea pasului este împărțită la rădăcina celei de-a doua medii, așa că parametrii cu gradienți mari sau zgomotoși fac pași mai mici. Coeficienții betas=(0.9, 0.95) stabilesc cât de repede uită cele două medii valorile vechi. Valoarea 0,95, în locul celei implicite de 0,999, face optimizatorul să reacționeze mai repede când scara gradienților se schimbă.

Litera W vine de la descreșterea ponderilor (weight decay), descrisă de Loshchilov și Hutter în 2017. La fiecare pas, ponderile sunt micșorate puțin, proporțional cu valoarea fiecăreia, ceea ce le împiedică să crească fără limită. Descreșterea, cu coeficientul 0,1, se aplică doar matricelor, adică parametrilor cu cel puțin două dimensiuni. Vectorii de bias și cei din normalizarea pe strat nu sunt micșorați.

Rata de învățare nu este constantă. În primii 100 de pași crește liniar de la aproape zero la 6⋅10−46 \cdot 10^{-4}. Această încălzire (warmup) evită pașii mari din primele momente, când gradienții modelului aleator sunt mari și instabili, iar mediile din AdamW nu s-au format încă. Apoi rata scade după o curbă cosinus, până la o zecime din valoarea maximă.

pretrain.py
LR = 6e-4
MIN_LR = LR / 10
WARMUP_STEPS = 100
def learning_rate(step, progress):
if step < WARMUP_STEPS:
return LR * (step + 1) / WARMUP_STEPS
return MIN_LR + 0.5 * (LR - MIN_LR) * (1 + math.cos(math.pi * progress))

Antrenarea are un buget de timp, nu un număr fix de pași, ca să se potrivească oricărui calculator. De aceea, curba cosinus urmează fracțiunea de timp deja consumată (progress) și ajunge la valoarea minimă exact când se termină timpul. Codul de mai jos afișează programul pentru o antrenare de 1.284 de pași, cât a făcut rularea de mai jos.

import math
LR = 6e-4
MIN_LR = LR / 10
WARMUP_STEPS = 100
def learning_rate(step, progress):
if step < WARMUP_STEPS:
return LR * (step + 1) / WARMUP_STEPS
return MIN_LR + 0.5 * (LR - MIN_LR) * (1 + math.cos(math.pi * progress))
total_steps = 1284
for step in [0, 25, 50, 99, 100, 250, 500, 642, 750, 1000, 1283]:
lr = learning_rate(step, step / total_steps)
print(f"pasul {step:>4}: {lr:.1e} {'#' * round(lr / LR * 40)}")

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Primii 100 de pași sunt doar 8% din antrenare, așa că la pasul 100 cosinusul a coborât deja puțin sub valoarea maximă. Pașii mari de la început aduc rapid modelul într-o zonă bună, iar pașii mici de la sfârșit îl stabilizează.

import numpy as np
# Gradienții a doi parametri, ca în clip_grad_norm_(model.parameters(), 1.0).
grads = [np.array([3.0, -1.0]), np.array([[2.0, 0.5], [-1.0, 1.5]])]
max_norm = 1.0
total_norm = np.sqrt(sum((g ** 2).sum() for g in grads))
scale = min(1.0, max_norm / total_norm)
clipped = [g * scale for g in grads]
print(f"Lungimea inițială: {total_norm:.3f}, factor: {scale:.3f}")
print(f"Lungimea după limitare: {np.sqrt(sum((g ** 2).sum() for g in clipped)):.3f}")
print(clipped[0])

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Funcția estimate_loss măsoară pierderea medie pe 20 de loturi din fiecare parte a datelor, cu modelul în modul de evaluare, adică fără dropout și fără calculul gradienților.

pretrain.py
@torch.no_grad()
def estimate_loss(model, splits, batches=20):
model.eval()
device = next(model.parameters()).device
losses = {}
for name, data in splits.items():
total = 0.0
for _ in range(batches):
x, y = get_batch(data, model.config.block_size, BATCH_SIZE, device)
total += model(x, y)[1].item()
losses[name] = total / batches
model.train()
return losses

Funcția main pune totul cap la cap.

pretrain.py
def main(minutes):
torch.manual_seed(1337)
device = pick_device()
tokenizer = load_tokenizer()
config = GPTConfig(vocab_size=len(tokenizer))
model = GPT(config).to(device)
splits = {
split: np.memmap(os.path.join(DATA_DIR, f"{split}.bin"), dtype=np.uint16, mode="r")
for split in ("train", "valid")
}
print(f"{model.num_params():,} parametri pe {device}, {len(splits['train']):,} tokenuri de antrenare")
params = list(model.parameters())
optimizer = torch.optim.AdamW(
[
{"params": [p for p in params if p.dim() >= 2], "weight_decay": 0.1},
{"params": [p for p in params if p.dim() < 2], "weight_decay": 0.0},
],
lr=LR,
betas=(0.9, 0.95),
)
writer = SummaryWriter(os.path.join(RUNS, time.strftime("pretrain-%Y%m%d-%H%M%S")))
def evaluate(step):
losses = estimate_loss(model, splits)
story = write(model, tokenizer, "Once upon a time", max_new_tokens=40)
writer.add_scalar("loss/train", losses["train"], step)
writer.add_scalar("loss/valid", losses["valid"], step)
writer.add_text("sample", story, step)
writer.flush()
print(f"pasul {step:>5} | antrenare {losses['train']:.3f} | validare {losses['valid']:.3f} | {story}", flush=True)
save_checkpoint(os.path.join(RUN_DIR, f"step-{step}.pt"), model, tokenizer, step=step)
budget = minutes * 60
start = last = time.time()
step = 0
evaluate(step)
while (elapsed := time.time() - start) < budget:
lr = learning_rate(step, elapsed / budget)
for group in optimizer.param_groups:
group["lr"] = lr
x, y = get_batch(splits["train"], config.block_size, BATCH_SIZE, device)
_, loss = model(x, y)
optimizer.zero_grad(set_to_none=True)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
step += 1
if step % 50 == 0:
now = time.time()
speed = 50 * BATCH_SIZE * config.block_size / (now - last)
last = now
writer.add_scalar("loss/batch", loss.item(), step)
writer.add_scalar("lr", lr, step)
writer.add_scalar("tokens_per_s", speed, step)
print(f"pasul {step:>5} | pierdere {loss.item():.3f} | lr {lr:.1e} | {speed:,.0f} tokenuri/s", flush=True)
if step % EVAL_EVERY == 0:
evaluate(step)
last = time.time()
if step % EVAL_EVERY != 0:
evaluate(step)
writer.close()
save_checkpoint(os.path.join(RUN_DIR, "model.pt"), model, tokenizer, step=step)
print(f"gata: {step:,} pași, {step * BATCH_SIZE * config.block_size:,} tokenuri, "
f"{(time.time() - start) / 60:.1f} minute")

Fiecare pas al procesului face aceleași cinci operații.

  1. Rata de învățare este calculată după programul de mai sus, cu încălzire și apoi scădere după o curbă cosinus, și este transmisă optimizatorului.
  2. Alegerea lotului ia un lot aleator (x, y) din fișierul binar de antrenare.
  3. Propagarea directă (forward pass) trece datele prin model și calculează pierderea prin entropie încrucișată.
  4. Retropropagarea și limitarea (backward pass) calculează gradienții (loss.backward()) și le limitează norma la 1,0 (clip_grad_norm_).
  5. Actualizarea parametrilor modifică ponderile cu un pas AdamW (optimizer.step()), după care gradienții sunt șterși (optimizer.zero_grad()).

zero_grad șterge gradienții pasului anterior, pe care altfel PyTorch i-ar aduna la cei noi. La fiecare 50 de pași se afișează pierderea lotului curent, rata de învățare și viteza, în tokenuri pe secundă. La fiecare 250 de pași, funcția evaluate măsoară pierderea pe datele de antrenare și pe cele de validare, generează începutul unei povești și salvează modelul într-un fișier separat, ca să-l putem compara mai târziu cu celelalte. Apelul torch.manual_seed(1337) face ca două rulări pe același dispozitiv să pornească din aceleași ponderi și să aleagă aceleași loturi.

Argumentul comenzii este bugetul de timp, în minute.

Terminal window
python pretrain.py 10

Rezultatul de mai jos vine din antrenarea de 10 minute din seria video a laboratorului, pe un laptop modern, cu un cip Apple Silicon (MPS). Am omis o parte din liniile afișate la fiecare 50 de pași.

14,585,856 parametri pe mps, 19,853,261 tokenuri de antrenare
pasul 0 | antrenare 9.324 | validare 9.325 | Once upon a time aren dismay mud Fragile sung passed disappearing Get Petal dead witch growling sunburn Patch onion sunburn Skip Barks napkins poles drip passed cautiously moms inspired asleep insisted insisted recorded feeder performers tear sliding rested bullets giving quilt hooted cuddle recommendations
pasul 50 | pierdere 5.272 | lr 3.0e-04 | 23,454 tokenuri/s
pasul 100 | pierdere 4.124 | lr 6.0e-04 | 28,489 tokenuri/s
pasul 250 | antrenare 3.184 | validare 3.205 | Once upon a time, there was a little girl named Lily. She loved to do was a big box. She was so happy. One day, Lily went to her ball with her friends. She wanted to go to
pasul 500 | antrenare 2.669 | validare 2.669 | Once upon a time, there was a smart cat named Lily. She loved to play with her toys and toys. One day, Lily wanted to buy a toy gun to play with her toys. She asked her mom,
pasul 750 | antrenare 2.453 | validare 2.430 | Once upon a time, there was a little girl named Lily. She loved to play with her friends in the park. One sunny day, Lily saw a big building in the park. She wanted to see it, but
pasul 1000 | antrenare 2.288 | validare 2.290 | Once upon a time, there was a little girl named Lily. She loved to play with her toys and her toys. One day, she got a big red ball in her room. It was a small, friendly cat
pasul 1250 | antrenare 2.226 | validare 2.253 | Once upon a time, there was a small dog named Max. Max loved to run and play all day. One day, Max and his ball went to the park. Max saw a big tree and decided to play with
pasul 1284 | antrenare 2.246 | validare 2.215 | Once upon a time, there was a big red ball. The ball was a normal ball. The ball went to the kids and wanted to play with the ball. They all sat under the tree and sat on the ball
gata: 1,284 pași, 15,777,792 tokenuri, 10.1 minute

La pasul 0, modelul alege cuvinte la întâmplare din vocabular. După 250 de pași apar propozițiile și un personaj cu nume, deși gramatica are încă greșeli („She loved to do was a big box”). De la 750 de pași, poveștile păstrează un fir pe parcursul câtorva propoziții. Pierderea pe validare scade de la 9,325 la 2,215, adică o perplexitate de aproximativ 9,2: din 10.000 de tokenuri posibile, modelul ezită, în medie, între câteva. Cele două pierderi rămân aproape egale până la final, deci modelul nu a memorat datele de antrenare. În 10 minute, modelul a făcut 1.284 de pași și a văzut 15,8 milioane de tokenuri, mai puțin decât întregul set de antrenare, de 19,9 milioane.

Viteza depinde mult de hardware. Rularea de mai sus a procesat circa 28.000 de tokenuri pe secundă. O placă grafică NVIDIA face mai mulți pași în același timp, iar un procesor obișnuit, mult mai puțini: pe un procesor cu 4 nuclee, cele 10 minute ajung doar pentru câteva zeci de pași, iar pierderea rămâne aproape de 5, ca la pasul 50 de mai sus. Pentru că generatorul de numere aleatoare pornește mereu de la aceeași valoare, pierderile din primii pași ies foarte apropiate de cele de mai sus pe orice calculator, iar numărul de pași și pierderea finală depind de viteza calculatorului.

Fiecare antrenare își scrie valorile în directorul runs/, iar TensorBoard le afișează ca grafice.

Terminal window
tensorboard --logdir runs

Modelul final este salvat în checkpoints/pretrain/model.pt, iar modelele salvate pe parcurs, de exemplu step-250.pt, în același director. Pe pagina următoare le folosim pentru a genera povești.