Generarea textului
La antrenare, modelul vede textul întreg și prezice toate pozițiile deodată. La generare, textul nu există încă, așa că modelul îl scrie câte un token la fiecare pas, după schema din secțiunea cum este generat textul.
La redare, playerul se încarcă de pe YouTube (detalii).
Procesul de generare
Secțiune intitulată „Procesul de generare” @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 idxLa fiecare token generat, procesul parcurge aceiași cinci pași.
- Trunchierea contextului păstrează cel mult ultimele 256 de tokenuri din secvență, pentru că modelul are doar 256 de poziții învățate.
- Extragerea scorurilor păstrează doar scorurile nenormalizate (logits) ale ultimei poziții, singura de care avem nevoie pentru următorul token.
- Scalarea și filtrarea împart scorurile la temperatura și, opțional, păstrează doar cele mai mari scoruri (eșantionare top-k).
- Calculul probabilităților și alegerea tokenului folosesc funcția softmax, care transformă scorurile rămase într-o distribuție de probabilitate. Din această distribuție,
torch.multinomialextrage la întâmplare noul token. - Adăugarea tokenului lipește tokenul ales la finalul secvenței. Procesul continuă până când modelul generează tokenul de sfârșit
<|endoftext|>sau până se ajunge la limita demax_new_tokenspași.
Decoratorul @torch.no_grad() oprește calculul gradienților, de care nu avem nevoie la generare. La fiecare pas, modelul recalculează toată fereastra, deși s-a schimbat doar tokenul nou. Modelele mari evită această risipă cu memoria cache pentru chei și valori. Pentru povești de câteva sute de tokenuri și un model de 14,6 milioane de parametri, varianta simplă este suficient de rapidă.
Temperatura și eșantionarea top-k
Secțiune intitulată „Temperatura și eșantionarea top-k”Exemplul de mai jos înlocuiește rețeaua cu un model mult mai simplu, construit din eșantionul de povești: un model de bigrame (bigram model). În acest model, scorul următorului token depinde doar de tokenul curent și este logaritmul numărului de apariții ale perechii. Procesul de generare este același ca în generate.
import numpy as npfrom tokenizer import WordTokenizer, build_vocab
vocab, _ = build_vocab(["povesti.txt"], size=2000)tokenizer = WordTokenizer(vocab)with open("povesti.txt", encoding="utf-8") as f: ids = tokenizer.encode(f.read())
# Scorul perechii (a, b) este logaritmul numărului de apariții ale lui b după a.# Perechile care nu apar în eșantion primesc -inf, adică probabilitatea zero.V = len(tokenizer)counts = np.zeros((V, V))np.add.at(counts, (ids[:-1], ids[1:]), 1)logits_table = np.where(counts > 0, np.log(np.maximum(counts, 1)), -np.inf)
def generate(idx, max_new_tokens, temperature=1.0, top_k=None, eos_id=None, rng=None): for _ in range(max_new_tokens): logits = logits_table[idx[-1]] / temperature if top_k is not None: kth = np.sort(logits)[-top_k] logits = np.where(logits < kth, -np.inf, logits) probs = np.exp(logits - logits.max()) probs /= probs.sum() next_id = int(rng.choice(V, p=probs)) idx = idx + [next_id] if next_id == eos_id: break return idx
def probabilities(token, temperature): logits = logits_table[tokenizer.token_to_id[token]] / temperature probs = np.exp(logits - logits.max()) probs /= probs.sum() top = np.argsort(probs)[::-1][:5] return ", ".join(f"{tokenizer.id_to_token[i]} {probs[i]:.0%}" for i in top)
for temperature in [0.5, 1.0, 2.0]: print(f"După „the”, la temperatura {temperature}: {probabilities('the', temperature)}")print()
prompt = tokenizer.encode("Once upon a time")for temperature, top_k in [(0.8, 50), (1.5, None)]: rng = np.random.default_rng(seed=1) out = generate(prompt, 40, temperature, top_k, tokenizer.eot_id, rng) print(f"Temperatura {temperature}, top_k {top_k}:") print(" ", tokenizer.decode(out))Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
La temperatura 0,5, primele continuări după „the” primesc o parte mult mai mare din probabilitate decât la temperatura 1. La temperatura 2, probabilitatea se împarte între mult mai multe cuvinte. Fiecare pereche de cuvinte din textele generate este plauzibilă, dar propozițiile nu au sens, pentru că modelul de bigrame vede un singur token înapoi. Modelul GPT vede până la 256 de tokenuri înapoi, așa că poate păstra un personaj sau o întâmplare pe parcursul mai multor propoziții.
Scriptul de generare
Secțiune intitulată „Scriptul de generare”Fișierul sample.py încarcă un model salvat și scrie povești pornind de la un prompt.
"""Povești scrise de un model antrenat, token cu token, cu temperatură și filtrare top-k."""
import argparseimport textwrap
import torch
from checkpoint import load_checkpointfrom model import pick_device
def write(model, tokenizer, prompt, max_new_tokens=200, temperature=0.8, top_k=50, with_prompt=True): was_training = model.training model.eval() device = next(model.parameters()).device ids = torch.tensor([tokenizer.encode(prompt)], device=device) out = model.generate(ids, max_new_tokens, temperature, top_k, eos_id=tokenizer.eot_id) model.train(was_training) return tokenizer.decode(out[0].tolist() if with_prompt else out[0, ids.size(1) :].tolist())
def main(): parser = argparse.ArgumentParser(description="Povești scrise de un model antrenat.") parser.add_argument("checkpoint") parser.add_argument("prompt", nargs="?", default="Once upon a time") parser.add_argument("-n", "--stories", type=int, default=2) parser.add_argument("--tokens", type=int, default=200) parser.add_argument("--temperature", type=float, default=0.8) parser.add_argument("--top-k", type=int, default=50) parser.add_argument("--seed", type=int, default=0) args = parser.parse_args()
torch.manual_seed(args.seed) model, tokenizer, _ = load_checkpoint(args.checkpoint, pick_device()) for _ in range(args.stories): story = write(model, tokenizer, args.prompt, args.tokens, args.temperature, args.top_k or None) print(textwrap.fill(story, width=90), end="\n\n")
if __name__ == "__main__": main()Funcția write este folosită și în timpul antrenării, pentru poveștile afișate la fiecare evaluare. Funcția trece modelul în modul de evaluare, ca dropout-ul să fie oprit, apoi îl readuce în modul în care l-a găsit.
Implicit, poveștile au cel mult 200 de tokenuri noi, temperatura 0,8 și filtrul top-k de 50. Opțiunea --top-k 0 oprește filtrarea: expresia args.top_k or None transformă valoarea 0 în None, iar generate păstrează atunci toate tokenurile. Opțiunea --seed alege valoarea de pornire a generatorului de numere aleatoare, deci aceeași comandă scrie de fiecare dată aceleași povești, pe același dispozitiv.
Povești generate local
Secțiune intitulată „Povești generate local”Modelul salvat la pasul 0, înainte de orice antrenare, dă probabilități aproape egale tuturor celor 10.000 de tokenuri, așa că alege cuvintele aproape la întâmplare.
python sample.py checkpoints/pretrain/step-0.pt -n 1 --tokens 40Once upon a time doing recommended reassure recommended cap honeycomb displayed takingCarly flight Captain stash slippers Leopard recommended ant proves wax plop Ivy burgerswonderland Hops everyone France deck forwards padlock peeking courageous want crookedrescues peck janitor Roses Softy Watching Watching formingMai jos sunt două povești scrise, cu setările implicite, de modelul preantrenat timp de 10 minute în rularea de pe pagina despre preantrenare. Ca și celelalte rezultate de pe această pagină, poveștile vin din seria video a laboratorului.
python sample.py checkpoints/pretrain/model.ptOnce upon a time, there was a little girl named Sue. She had a toy cat named Lucy. Sueloved to play with her toy train. One day, she decided to play with her toy train withher. She would throw the train with her toy train as she was as fast as she could. Atnight, Sue heard a voice voice. "What is this?" she said. "I am playing with toys," Timthought it was the same toy. He started to play with the jeep. He thought the other trainwould be fun to be the best car. But then, the Buddy turned around the town. He did notwant to play with it again. He was sad. Sue had an idea. She made a big, scary, big,yellow train. She kept playing with the train with her long, but she was not looking forit. She could not catch it, and she was very sad. She had an idea. She had an idea. Timand Sue played with the train
Once upon a time, there was a big dog named Spot. Spot loved to play with his best friend,a small cat named Kitty. They liked to play together in the sun. One day, while they wereplaying, Spot saw a big, shiny stone. He wanted to play with it, but he knew it was safe.Spot ran to the stone and found a big leaf. He picked it up and took it to Kitty. Kittydid not like the stone, but he was not happy. The stone made Tim sad. It knew it was agood place to play with. Spot and Kitty played with the stone all day long. They had a lotof fun. And from that day on, Spot never forgot to be more careful with his new friend,always with their new friend.Gramatica este aproape corectă, iar poveștile au personaje, o întâmplare și o încercare de final. Logica slăbește însă pe parcurs: în prima poveste apare dintr-odată un Tim, iar în a doua, piatra îl întristează pe Tim, care nu face parte din poveste. Prima poveste ajunge la limita de 200 de tokenuri și se oprește la mijlocul unei propoziții. A doua se încheie singură, cu tokenul <|endoftext|>.
La o temperatură mică, modelul alege aproape mereu continuările cele mai probabile.
python sample.py checkpoints/pretrain/model.pt -n 1 --temperature 0.3Once upon a time, there was a little girl named Lily. She had a big, soft bed. Lily lovedto play with her toys. One day, Lily saw a big box in the box. She wanted to open it, butshe was too small. Lily's mom saw her and said, "Lily, you can open the box!" Lily wasvery happy and said, "Thank you, Lily!" They played with the box all day. They had a lotof fun. And from that day on, Lily and her mom always played together.Povestea este scurtă și se încheie singură, dar este previzibilă: o fetiță numită Lily, o cutie, mama și formula „And from that day on”, care apare în foarte multe povești din setul de date. Nici aici logica nu este perfectă, pentru că Lily îi mulțumește lui Lily.
La o temperatură mare și fără filtrul top-k, distribuția devine aproape plată, iar modelul alege des tokenuri rare. Mai jos este doar începutul textului.
python sample.py checkpoints/pretrain/model.pt -n 1 --temperature 1.5 --top-k 0Once upon a time shook learning new disturbed triangles down than did feeding a whilecrayon '! ready her crayons up off out eager to continue flying onto her person sprayedcrafts. Silver held flew dark legs around, he kicked her again cleaning the unpackingcarefully fireman greater around eraser together as she was touching an bald Leah memory…Fiecare cuvânt vine din vocabularul poveștilor, dar textul nu mai are nici gramatică, nici fir, și nu se oprește până la limita de 200 de tokenuri.
Unde privește atenția
Secțiune intitulată „Unde privește atenția”Pe pagina despre atenția scrisă de mână, ponderile de atenție veneau din matrice aleatoare și nu aveau un sens. Fișierul attention_map.py arată unde se uită fiecare cap al modelului antrenat, pornind de la ultimul token al unei propoziții.
@torch.no_grad()def attention_maps(model, ids): inputs = [] hooks = [block.attn.register_forward_hook(lambda module, args, out: inputs.append(args[0])) for block in model.blocks] logits, _ = model(ids) for hook in hooks: hook.remove() maps = [] for block, x in zip(model.blocks, inputs): attn = block.attn B, T, C = x.shape q = attn.q_proj(x).view(B, T, attn.n_head, C // attn.n_head).transpose(1, 2) k = attn.k_proj(x).view(B, T, attn.n_head, C // attn.n_head).transpose(1, 2) scores = q @ k.transpose(-2, -1) / math.sqrt(C // attn.n_head) future = torch.triu(torch.ones(T, T, dtype=torch.bool, device=x.device), diagonal=1) maps.append(F.softmax(scores.masked_fill(future, float("-inf")), dim=-1)[0]) return torch.stack(maps), logits[0, -1]Funcția F.scaled_dot_product_attention, folosită de model, nu întoarce ponderile de atenție, așa că attention_maps le recalculează. Pe stratul de atenție al fiecărui bloc, register_forward_hook pune un forward hook, o funcție pe care PyTorch o apelează la fiecare trecere prin strat și care păstrează aici intrarea stratului. După o trecere prin model, funcțiile sunt scoase, iar pentru fiecare bloc se refac interogările și cheile, cu proiecțiile stratului. Scorurile, masca cauzală și softmax urmează apoi exact funcția attention din attention.py. Rezultatul are forma (6, 6, T, T): straturi, capete și câte o matrice de ponderi pentru fiecare cap. Funcția întoarce și scorurile modelului pentru tokenul care ar urma după propoziție.
def main(): parser = argparse.ArgumentParser(description="Atenția unui model antrenat.") parser.add_argument("checkpoint") parser.add_argument("prompt", nargs="?", default="Tom and Lily went to the park. Tom gave the ball to") args = parser.parse_args()
device = pick_device() model, tokenizer, _ = load_checkpoint(args.checkpoint, device) model.eval() ids = tokenizer.encode(args.prompt) tokens = [tokenizer.id_to_token[i] for i in ids] maps, logits = attention_maps(model, torch.tensor([ids], device=device)) top = torch.topk(F.softmax(logits, dim=-1), 3) print(" ".join(tokens)) print("următorul token: " + ", ".join(f"{tokenizer.id_to_token[i]} {p:.0%}" for p, i in zip(top.values.tolist(), top.indices.tolist()))) last = maps[:, :, -1, :] for layer in range(last.size(0)): cells = [] for head in range(last.size(1)): j = last[layer, head].argmax().item() cells.append(f"{tokens[j]:>5} {last[layer, head, j].item():.2f}") print(f"stratul {layer + 1} | " + " | ".join(cells))Propoziția implicită este „Tom and Lily went to the park. Tom gave the ball to”. Scriptul afișează cele mai probabile trei continuări, apoi, pentru fiecare strat și fiecare cap, tokenul la care ultimul token, to, se uită cel mai mult, cu ponderea respectivă.
python attention_map.py checkpoints/pretrain/model.ptTom and Lily went to the park . Tom gave the ball tourmătorul token: Lily 52%, the 20%, Tom 8%stratul 1 | gave 0.52 | gave 0.33 | ball 0.18 | ball 0.26 | the 0.13 | gave 0.50stratul 2 | gave 0.36 | ball 0.33 | gave 0.38 | to 0.21 | gave 0.24 | . 0.46stratul 3 | . 0.39 | Tom 0.24 | to 0.21 | gave 0.38 | ball 0.31 | to 0.56stratul 4 | ball 0.30 | to 0.28 | ball 0.64 | Tom 0.83 | Lily 0.61 | Lily 0.52stratul 5 | Lily 0.56 | to 0.49 | . 0.25 | Tom 0.49 | Tom 0.24 | Tom 0.54stratul 6 | the 0.32 | park 0.44 | Lily 0.55 | Tom 0.53 | Tom 0.11 | ball 0.47Modelul prezice că urmează „Lily”, cu probabilitatea de 52%, deși propoziția nu spune cui i-a dat Tom mingea. „Tom” primește doar 8%: din povești, modelul a învățat că, după „Tom gave the ball to”, urmează de obicei celălalt personaj. În primele trei straturi, capetele se uită mai ales la cuvintele din apropiere (gave, ball, to) și la punct. În straturile 4–6, 10 dintre cele 18 capete se uită cel mai mult la unul dintre nume: la Tom, cu ponderi de până la 0,83, sau la Lily, cu ponderi între 0,52 și 0,61. Tabelul arată doar tokenul preferat al fiecărui cap, așa că nu explică singur cum ajunge modelul la răspuns. Arată însă că, după antrenare, capetele nu mai împart atenția la întâmplare, ci caută informația de care este nevoie pentru următorul cuvânt.
Modelul preantrenat continuă orice text ca pe începutul unei povești. Nu știe să urmeze o cerere, de exemplu să folosească anumite cuvinte. Va învăța acest lucru în etapa următoare, prin ajustarea fină supervizată.
Bibliografie
Secțiune intitulată „Bibliografie”- Fan, A., Lewis, M. și Dauphin, Y. (2018). Hierarchical Neural Story Generation. ACL 2018.
- Holtzman, A. et al. (2020). The Curious Case of Neural Text Degeneration. ICLR 2020.
- Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. Raport tehnic OpenAI.
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.