Preantrenarea
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).
Obiectivul
Secțiune intitulată „Obiectivul”Pentru o fereastră de tokenuri , modelul dă la fiecare poziție 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
unde este distribuția calculată de model cu parametrii .
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 să vadă tokenul 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 . O mărime mai ușor de interpretat este perplexitatea (perplexity), , 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_000print(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).
Loturile
Secțiune intitulată „Loturile”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.
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 npfrom 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).
Optimizatorul
Secțiune intitulată „Optimizatorul”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
Secțiune intitulată „Rata de învățare”Rata de învățare nu este constantă. În primii 100 de pași crește liniar de la aproape zero la . 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ă.
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-4MIN_LR = LR / 10WARMUP_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 = 1284for 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ă.
Limitarea gradientului
Secțiune intitulată „Limitarea gradientului”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).
Procesul de antrenare
Secțiune intitulată „Procesul de antrenare”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.
@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 lossesFuncția main pune totul cap la cap.
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.
- 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.
- Alegerea lotului ia un lot aleator
(x, y)din fișierul binar de antrenare. - Propagarea directă (forward pass) trece datele prin model și calculează pierderea prin entropie încrucișată.
- Retropropagarea și limitarea (backward pass) calculează gradienții (
loss.backward()) și le limitează norma la 1,0 (clip_grad_norm_). - 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.
python pretrain.py 10Rezultatul 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 antrenarepasul 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 recommendationspasul 50 | pierdere 5.272 | lr 3.0e-04 | 23,454 tokenuri/spasul 100 | pierdere 4.124 | lr 6.0e-04 | 28,489 tokenuri/spasul 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 topasul 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, butpasul 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 catpasul 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 withpasul 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 ballgata: 1,284 pași, 15,777,792 tokenuri, 10.1 minuteLa 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.
Urmărirea în TensorBoard
Secțiune intitulată „Urmărirea în TensorBoard”Fiecare antrenare își scrie valorile în directorul runs/, iar TensorBoard le afișează ca grafice.
tensorboard --logdir runsModelul 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.
Bibliografie
Secțiune intitulată „Bibliografie”- Goyal, P. et al. (2017). Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour. Preprint arXiv:1706.02677.
- Kingma, D. P. și Ba, J. (2015). Adam: A Method for Stochastic Optimization. ICLR 2015.
- Loshchilov, I. și Hutter, F. (2017). SGDR: Stochastic Gradient Descent with Warm Restarts. ICLR 2017.
- Loshchilov, I. și Hutter, F. (2019). Decoupled Weight Decay Regularization. ICLR 2019. ↩︎
- Pascanu, R., Mikolov, T. și Bengio, Y. (2013). On the difficulty of training Recurrent Neural Networks. ICML 2013.
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.