Salt la conținut

Generarea textului

IntermediarLectură: 6 min

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

Episodul 7Generarea textului (sampling) cu temperatură și top-kcapitolul „Generarea textului, token cu token”
model.py
@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

La fiecare token generat, procesul parcurge aceiași cinci pași.

  1. Trunchierea contextului păstrează cel mult ultimele 256 de tokenuri din secvență, pentru că modelul are doar 256 de poziții învățate.
  2. Extragerea scorurilor păstrează doar scorurile nenormalizate (logits) ale ultimei poziții, singura de care avem nevoie pentru următorul token.
  3. Scalarea și filtrarea împart scorurile la temperatura TT și, opțional, păstrează doar cele mai mari kk scoruri (eșantionare top-k).
  4. 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.multinomial extrage la întâmplare noul token.
  5. 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 de max_new_tokens paș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ă.

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 np
from 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.

Fișierul sample.py încarcă un model salvat și scrie povești pornind de la un prompt.

sample.py
"""Povești scrise de un model antrenat, token cu token, cu temperatură și filtrare top-k."""
import argparse
import textwrap
import torch
from checkpoint import load_checkpoint
from 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.

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.

Terminal window
python sample.py checkpoints/pretrain/step-0.pt -n 1 --tokens 40
Once upon a time doing recommended reassure recommended cap honeycomb displayed taking
Carly flight Captain stash slippers Leopard recommended ant proves wax plop Ivy burgers
wonderland Hops everyone France deck forwards padlock peeking courageous want crooked
rescues peck janitor Roses Softy Watching Watching forming

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

Terminal window
python sample.py checkpoints/pretrain/model.pt
Once upon a time, there was a little girl named Sue. She had a toy cat named Lucy. Sue
loved to play with her toy train. One day, she decided to play with her toy train with
her. She would throw the train with her toy train as she was as fast as she could. At
night, Sue heard a voice voice. "What is this?" she said. "I am playing with toys," Tim
thought it was the same toy. He started to play with the jeep. He thought the other train
would be fun to be the best car. But then, the Buddy turned around the town. He did not
want 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 for
it. She could not catch it, and she was very sad. She had an idea. She had an idea. Tim
and 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 were
playing, 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. Kitty
did not like the stone, but he was not happy. The stone made Tim sad. It knew it was a
good place to play with. Spot and Kitty played with the stone all day long. They had a lot
of 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.

Terminal window
python sample.py checkpoints/pretrain/model.pt -n 1 --temperature 0.3
Once upon a time, there was a little girl named Lily. She had a big, soft bed. Lily loved
to play with her toys. One day, Lily saw a big box in the box. She wanted to open it, but
she was too small. Lily's mom saw her and said, "Lily, you can open the box!" Lily was
very happy and said, "Thank you, Lily!" They played with the box all day. They had a lot
of 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.

Terminal window
python sample.py checkpoints/pretrain/model.pt -n 1 --temperature 1.5 --top-k 0
Once upon a time shook learning new disturbed triangles down than did feeding a while
crayon '! ready her crayons up off out eager to continue flying onto her person sprayed
crafts. Silver held flew dark legs around, he kicked her again cleaning the unpacking
carefully 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.

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.

attention_map.py
@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.

attention_map.py
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ă.

Terminal window
python attention_map.py checkpoints/pretrain/model.pt
Tom and Lily went to the park . Tom gave the ball to
urmă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.50
stratul 2 | gave 0.36 | ball 0.33 | gave 0.38 | to 0.21 | gave 0.24 | . 0.46
stratul 3 | . 0.39 | Tom 0.24 | to 0.21 | gave 0.38 | ball 0.31 | to 0.56
stratul 4 | ball 0.30 | to 0.28 | ball 0.64 | Tom 0.83 | Lily 0.61 | Lily 0.52
stratul 5 | Lily 0.56 | to 0.49 | . 0.25 | Tom 0.49 | Tom 0.24 | Tom 0.54
stratul 6 | the 0.32 | park 0.44 | Lily 0.55 | Tom 0.53 | Tom 0.11 | ball 0.47

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