Lidsky řečeno
Znáš hru „dokonči větu“. Někdo řekne „Pes zahlédl…“ a ty doplníš „kočku“. Pokud ti dá pět slov před koncem, odhadneš líp než s jedním. Náš model dělá to samé na úrovni písmen. Vidí několik posledních znaků a hádá další. Nejdřív mu necháme vidět jediný znak, potom víc, a změříme, o kolik je chytřejší. Celá mise vlastně odpovídá na otázku, co všechno musí model vidět, aby dobře hádal.
Každá ukázka běží samostatně, proto se v blocích opakuje generátor textu. V reálném projektu by byl v jednom souboru.
Krok 1: text, slovník a trezor
Model počítá s čísly, ne se znaky. Každému znaku proto přidělíme číslo. Seznam všech znaků je slovník (vocabulary) a převodu textu na čísla se říká kódování.
Text vyrábí generátor. Každá věta má tvar „podmět sloveso předmět.“, podmět je v 1. pádě a předmět ve 4. pádě. Podmět a předmět se losují nezávisle, sloveso také. Tréninkový text vyrobíme s jedním semínkem náhody a validační (ověřovací, na kterém model nikdy neuvidí učení) s jiným. To je náš trezor z lekce Pipelines a únik dat: na validační text se při tréninku nesmí sáhnout.
import numpy as np
DVOJICE = [("pekař", "pekaře"), ("kočka", "kočku"), ("pes", "psa"),
("žák", "žáka"), ("kovář", "kováře"), ("včela", "včelu")]
SLOVESA = ["vidí", "hledá", "zná", "vítá"]
def korpus(n_vet, seed):
r = np.random.default_rng(seed)
vety = []
for _ in range(n_vet):
podmet = DVOJICE[r.integers(6)][0]
predmet = DVOJICE[r.integers(6)][1]
vety.append(f"{podmet} {SLOVESA[r.integers(4)]} {predmet}.")
return " ".join(vety)
trenink = korpus(500, seed=0)
overeni = korpus(100, seed=1)
znaky = sorted(set(trenink + overeni))
stoi = {c: i for i, c in enumerate(znaky)}
itos = {i: c for c, i in stoi.items()}
print("začátek textu:", trenink[:62])
print("znaků v textu:", len(trenink), "| ověřovací:", len(overeni))
print("velikost slovníku:", len(znaky))
print("slovník:", "".join(znaky))
print("kód věty 'psa.':", [stoi[c] for c in "psa."])
začátek textu: včela zná žáka. kočka vidí kočku. pekař vidí pekaře. kovář vít znaků v textu: 8545 | ověřovací: 1752 velikost slovníku: 22 slovník: .adehiklnopstuvzáíčřž kód věty 'psa.': [11, 12, 2, 1]
Mezera, tečka a písmena s diakritikou jsou normální znaky stejně jako ostatní. Model nevidí slova, jen proud znaků.
Úkol 1: slovník znaků
Napiš funkci slovnik(text), která vrátí dvojici slovníků (stoi, itos). Znaky se číslují od nuly v abecedním pořadí (použij sorted), každý znak jen jednou. stoi převádí znak na číslo, itos zpět.
def slovnik(text):
return {}, {}
Krok 2: nejjednodušší model, bigramy
Než postavíme síť, potřebujeme laťku, kterou musí překonat. Nejjednodušší model hledí na jediný předchozí znak. Spočítá, jak často po každém znaku následuje který další (bigramy), a z počtů udělá pravděpodobnosti. Tabulka N[a, b] říká, kolikrát po znaku a přišlo b. K počtům přičteme jedničku (vyhlazení), aby žádná pravděpodobnost nebyla přesně nulová.
Kvalitu měříme křížovou entropií (průměrný záporný logaritmus pravděpodobnosti, kterou model dal skutečnému znaku, v přirozených logaritmech). Čím nižší, tím lepší. Model, který by hádal všechny znaky stejně, má hodnotu ln(V), kde V je velikost slovníku.
U našeho textu navíc umíme spočítat podlahu: nejmenší hodnotu, které může dosáhnout kterýkoli model. Text je z části náhodný: v každé větě se losuje podmět (6 možností), sloveso (4) a předmět (6). Tuhle nejistotu nezruší žádný model, protože losování nelze předvídat. Zbytek textu je předvídatelný.
import numpy as np
DVOJICE = [("pekař", "pekaře"), ("kočka", "kočku"), ("pes", "psa"),
("žák", "žáka"), ("kovář", "kováře"), ("včela", "včelu")]
SLOVESA = ["vidí", "hledá", "zná", "vítá"]
def korpus(n_vet, seed):
r = np.random.default_rng(seed)
vety = []
for _ in range(n_vet):
podmet = DVOJICE[r.integers(6)][0]
predmet = DVOJICE[r.integers(6)][1]
vety.append(f"{podmet} {SLOVESA[r.integers(4)]} {predmet}.")
return " ".join(vety)
trenink, overeni = korpus(500, 0), korpus(100, 1)
znaky = sorted(set(trenink + overeni))
stoi = {c: i for i, c in enumerate(znaky)}
itos = {i: c for c, i in stoi.items()}
V = len(znaky)
tr = np.array([stoi[c] for c in trenink])
va = np.array([stoi[c] for c in overeni])
N = np.ones((V, V))
np.add.at(N, (tr[:-1], tr[1:]), 1)
P = N / N.sum(axis=1, keepdims=True)
def ztrata(ids):
return -np.mean(np.log(P[ids[:-1], ids[1:]]))
# podlaha: nejistota ze tří losování děleno průměrnou délkou věty
delka = (np.mean([len(a) for a, _ in DVOJICE]) + np.mean([len(b) for _, b in DVOJICE])
+ np.mean([len(v) for v in SLOVESA]) + 4)
podlaha = (2 * np.log(6) + np.log(4)) / delka
print(f"rovnoměrný tip: {np.log(V):.3f}")
print(f"bigram na tréninku: {ztrata(tr):.3f}")
print(f"bigram na ověření: {ztrata(va):.3f}")
print(f"podlaha (nejlepší): {podlaha:.3f}")
r = np.random.default_rng(0)
znak, vystup = stoi["p"], ["p"]
for _ in range(50):
znak = r.choice(V, p=P[znak])
vystup.append(itos[znak])
print("".join(vystup))
rovnoměrný tip: 3.091 bigram na tréninku: 1.024 bigram na ověření: 1.028 podlaha (nejlepší): 0.290 pedohlu. včk zelaředá kočkařvítá koá psnáka. ps vid
Bigram už umí tvary slov a pravidlo, že po tečce přijde mezera. Přesto věty skládá nesmyslně: mezery a hranice slov ho nezajímají, protože vidí jen poslední znak. Od podlahy je ještě daleko.
Úkol 2: vlastní měřidlo
Napiš funkci kriz_entropie(P, a, b). P je matice pravděpodobností (řádek je předchozí znak, sloupec další), a pole předchozích znaků a b pole skutečných dalších znaků (čísla). Vrať průměr -log P[a_i, b_i].
import numpy as np
def kriz_entropie(P, a, b):
return 0.0
Bigram dosáhl na ověřovacích datech skoro stejné ztráty jako na trénovacích. Co z toho plyne?
Bigramy mají jen V × V čísel, což je málo na zapamatování textu. Tréninková a ověřovací ztráta proto vyjdou podobně. Ztráta je ale daleko od podlahy, takže je model spíš podučený.
Krok 3: síť, která vidí víc znaků
Teď modelu necháme vidět několik posledních znaků, tzv. kontext (context window). Znaky v kontextu převedeme na malé vektory, tedy embeddingy, a slepíme je za sebe. Pak je protáhneme skrytou vrstvou s tanh a na konci dostaneme V čísel (logitů), ze kterých softmax udělá pravděpodobnosti dalšího znaku. Je to síť z lekce Neuronová síť od nuly, jen se vstupem z tabulky vektorů:
znaky v kontextu -> E[znak] -> slepení -> W1, tanh -> W2 -> softmax -> pravděpodobnosti
(ctx čísel) (ctx × d) (ctx·d) (H) (V)Zpětný průchod napíšeme ručně. Je to řetěz derivací, který už znáš z lekce Backpropagation. Zajímavá je jen první a poslední část:
- Gradient ztráty vůči logitům je překvapivě prostý: pravděpodobnosti minus jednička na správném znaku, děleno počtem vzorků.
- Embeddingy se do vstupu vybírají indexováním, takže gradient se musí do tabulky
Epřičíst na místa, odkud se vybíralo. Stejný znak se ve vzorku může objevit víckrát a jeho příspěvky se sečtou.
Ručně napsanému zpětnému průchodu se nevěří, dokud se nezkontroluje. Kontrola gradientu porovná analytický výsledek s číselnou derivací: každé číslo mírně posune nahoru a dolů a změří, jak se změní ztráta. Zkoušíme to na maličké síti, ať je výpočet rychlý.
import numpy as np
def forward(P, X):
x = P["E"][X].reshape(len(X), -1)
h = np.tanh(x @ P["W1"] + P["b1"])
return x, h, h @ P["W2"] + P["b2"]
def softmax(z):
e = np.exp(z - z.max(axis=1, keepdims=True))
return e / e.sum(axis=1, keepdims=True)
def ztrata(P, X, y):
p = softmax(forward(P, X)[2])
return -np.mean(np.log(p[np.arange(len(y)), y]))
def gradienty(P, X, y):
x, h, logity = forward(P, X)
B, ctx = X.shape
dl = softmax(logity)
dl[np.arange(B), y] -= 1
dl /= B
g = {"W2": h.T @ dl, "b2": dl.sum(axis=0)}
dp = (dl @ P["W2"].T) * (1 - h ** 2)
g["W1"], g["b1"] = x.T @ dp, dp.sum(axis=0)
dx = (dp @ P["W1"].T).reshape(B, ctx, -1)
g["E"] = np.zeros_like(P["E"])
np.add.at(g["E"], X, dx)
return g
V, ctx, d, H = 5, 3, 4, 6
rng = np.random.default_rng(0)
P = {"E": rng.normal(0, 0.5, (V, d)), "W1": rng.normal(0, 0.5, (ctx * d, H)),
"b1": rng.normal(0, 0.1, H), "W2": rng.normal(0, 0.5, (H, V)),
"b2": rng.normal(0, 0.1, V)}
X = rng.integers(0, V, (7, ctx))
y = rng.integers(0, V, 7)
g = gradienty(P, X, y)
for jmeno, matice in P.items():
cislo = np.zeros_like(matice)
for i in np.ndindex(*matice.shape):
puvodni = matice[i]
matice[i] = puvodni + 1e-6
nahoru = ztrata(P, X, y)
matice[i] = puvodni - 1e-6
dolu = ztrata(P, X, y)
matice[i] = puvodni
cislo[i] = (nahoru - dolu) / 2e-6
print(f"{jmeno:>2}: gradient sedí = {np.allclose(g[jmeno], cislo, atol=1e-7)}")
E: gradient sedí = True W1: gradient sedí = True b1: gradient sedí = True W2: gradient sedí = True b2: gradient sedí = True
Všech pět dílů sedí. Gradient embeddingů je přitom nejnáchylnější na chybu, jak ukáže další úkol.
Ztracený příspěvek v tabulce
Funkce má sečíst gradienty embeddingů do tabulky dE. Na ukázkových datech s unikátními znaky vypadala správně. Ve skutečné dávce se ale znaky opakují a síť se učí hůř.
Úkol 3: ztráta a její gradient
Napiš funkci ztrata_a_gradient(logity, y). logity má tvar (B, V) a y jsou správné znaky. Vrať dvojici: průměrnou křížovou entropii a gradient vůči logitům (stejného tvaru). Pozor na stabilitu: před exponenciálou odečti od každého řádku jeho maximum.
import numpy as np
def ztrata_a_gradient(logity, y):
return 0.0, np.zeros_like(logity)
Trénink a srovnání čtyř modelů
Teď všechno složíme dohromady. Funkce trenuj(ctx) vytvoří síť s oknem ctx znaků a trénuje ji minidávkami: v každém kroku vybere náhodných 64 oken, spočítá gradient a posune všechny váhy proti němu. Rychlost učení nejdřív 0,5 a v posledních krocích 0,1 (jemnější doladění).
Zkusíme okno velikosti 1, 2, 5 a 8 znaků. Sleduj hlavně ověřovací ztrátu, na tréninkové se přeučení nepozná.
import numpy as np
DVOJICE = [("pekař", "pekaře"), ("kočka", "kočku"), ("pes", "psa"),
("žák", "žáka"), ("kovář", "kováře"), ("včela", "včelu")]
SLOVESA = ["vidí", "hledá", "zná", "vítá"]
def korpus(n_vet, seed):
r = np.random.default_rng(seed)
vety = []
for _ in range(n_vet):
podmet = DVOJICE[r.integers(6)][0]
predmet = DVOJICE[r.integers(6)][1]
vety.append(f"{podmet} {SLOVESA[r.integers(4)]} {predmet}.")
return " ".join(vety)
trenink, overeni = korpus(500, 0), korpus(100, 1)
znaky = sorted(set(trenink + overeni))
stoi = {c: i for i, c in enumerate(znaky)}
itos = {i: c for c, i in stoi.items()}
V = len(znaky)
tr = np.array([stoi[c] for c in trenink])
va = np.array([stoi[c] for c in overeni])
def okna(ids, ctx):
X = np.stack([ids[i:i + ctx] for i in range(len(ids) - ctx)])
return X, ids[ctx:]
def softmax(z):
e = np.exp(z - z.max(axis=1, keepdims=True))
return e / e.sum(axis=1, keepdims=True)
def forward(P, X):
x = P["E"][X].reshape(len(X), -1)
h = np.tanh(x @ P["W1"] + P["b1"])
return x, h, h @ P["W2"] + P["b2"]
def ztrata(P, X, y):
p = softmax(forward(P, X)[2])
return -np.mean(np.log(p[np.arange(len(y)), y]))
def gradienty(P, X, y):
x, h, logity = forward(P, X)
B, ctx = X.shape
dl = softmax(logity)
dl[np.arange(B), y] -= 1
dl /= B
g = {"W2": h.T @ dl, "b2": dl.sum(axis=0)}
dp = (dl @ P["W2"].T) * (1 - h ** 2)
g["W1"], g["b1"] = x.T @ dp, dp.sum(axis=0)
dx = (dp @ P["W1"].T).reshape(B, ctx, -1)
g["E"] = np.zeros_like(P["E"])
np.add.at(g["E"], X, dx)
return g
def trenuj(ctx, d=8, H=48, kroku=6000, seed=0):
rng = np.random.default_rng(seed)
P = {"E": rng.normal(0, 0.3, (V, d)),
"W1": rng.normal(0, 1 / np.sqrt(ctx * d), (ctx * d, H)), "b1": np.zeros(H),
"W2": rng.normal(0, 0.1, (H, V)), "b2": np.zeros(V)}
X, y = okna(tr, ctx)
for krok in range(kroku):
lr = 0.5 if krok < 4000 else 0.1
i = rng.integers(0, len(X), 64)
g = gradienty(P, X[i], y[i])
for k in P:
P[k] -= lr * g[k]
return P
delka = (np.mean([len(a) for a, _ in DVOJICE]) + np.mean([len(b) for _, b in DVOJICE])
+ np.mean([len(v) for v in SLOVESA]) + 4)
podlaha = (2 * np.log(6) + np.log(4)) / delka
print("okno trénink ověření")
for ctx in [1, 2, 5, 8]:
P = trenuj(ctx)
a = ztrata(P, *okna(tr, ctx))
b = ztrata(P, *okna(va, ctx))
print(f"{ctx:>4} {a:7.3f} {b:7.3f}")
print(f"podlaha: {podlaha:.3f}")
okno trénink ověření 1 0.986 0.991 2 0.447 0.440 5 0.343 0.343 8 0.285 0.288 podlaha: 0.290
Čti tabulku shora dolů. S jedním znakem síť skončí zhruba u bigramu, protože víc nevidí. Každé rozšíření okna ztrátu srazí, dokud síť nedosáhne podlahy. To, že ověřovací ztráta u největšího okna leží těsně u podlahy nebo mírně pod ní, není chyba: podlaha je střední hodnota přes všechny možné texty a konkrétní ověřovací text může být o kousek předvídatelnější.
Proč pomáhá právě delší okno? Vezmi slovo pekař uprostřed věty. Po jeho posledním písmenu přijde mezera, pokud je to podmět, a e, pokud je to předmět (pekaře). Jestli je slovo podmět nebo předmět, ale prozradí až konec slovesa před ním (í nebo á ). Okno z pěti znaků ho nezahrnuje, okno z osmi už ano.
Síť s oknem 2 znaky má vyšší ověřovací ztrátu než síť s oknem 8. Který důvod je správný?
Nejistotu nezpůsobuje malý počet vah, ale to, že rozhodující informace leží mimo okno. Žádný trénink neumí využít znak, který model nevidí.
Krok 4: generování a teplota
Model nedává jednu odpověď, ale rozdělení pravděpodobností. Text se z něj generuje cyklem: model dostane kontext, vrátí pravděpodobnosti, z nich se vylosuje další znak, připojí se ke kontextu a opakuje se to.
Jak moc smí losování zbloudit, řídí teplota T. Logity se před softmaxem vydělí číslem T:
T < 1rozdíly zesílí, pravděpodobné znaky vyhrávají a text je opatrný a opakující se,T = 1je to, co se model naučil,T > 1rozdíly zploští, losují se i nepravděpodobné znaky a text bývá divočejší a plný chyb.
Totéž možná znáš z lekce Jak fungují velké jazykové modely, kde teplotu nastavuješ u chatbota.
Úkol 4: softmax s teplotou
Napiš funkci s_teplotou(logity, T), která vrátí pravděpodobnosti z jednorozměrného pole logitů po vydělení teplotou T. Nezapomeň na stabilní softmax (odečti maximum).
import numpy as np
def s_teplotou(logity, T):
return np.full(len(logity), 1 / len(logity))
Tahej teplotou a sleduj, jak se rozdělení mění. Tohle je přesně ten posuvník, který najdeš u chatbotů.
Odevzdání: celý model, tabulka a vzorky textu
Poslední ukázka je tvůj hotový model v jednom kusu: generátor textu, ručně psaný zpětný průchod, trénink a generování při různé teplotě. Používá okno osmi znaků, které v tabulce vyhrálo. Spusť ji a podívej se na výstup.
import numpy as np
DVOJICE = [("pekař", "pekaře"), ("kočka", "kočku"), ("pes", "psa"),
("žák", "žáka"), ("kovář", "kováře"), ("včela", "včelu")]
SLOVESA = ["vidí", "hledá", "zná", "vítá"]
def korpus(n_vet, seed):
r = np.random.default_rng(seed)
vety = []
for _ in range(n_vet):
podmet = DVOJICE[r.integers(6)][0]
predmet = DVOJICE[r.integers(6)][1]
vety.append(f"{podmet} {SLOVESA[r.integers(4)]} {predmet}.")
return " ".join(vety)
trenink, overeni = korpus(500, 0), korpus(100, 1)
znaky = sorted(set(trenink + overeni))
stoi = {c: i for i, c in enumerate(znaky)}
itos = {i: c for c, i in stoi.items()}
V, CTX = len(znaky), 8
tr = np.array([stoi[c] for c in trenink])
va = np.array([stoi[c] for c in overeni])
def okna(ids):
X = np.stack([ids[i:i + CTX] for i in range(len(ids) - CTX)])
return X, ids[CTX:]
def softmax(z):
e = np.exp(z - z.max(axis=-1, keepdims=True))
return e / e.sum(axis=-1, keepdims=True)
def forward(P, X):
x = P["E"][X].reshape(len(X), -1)
h = np.tanh(x @ P["W1"] + P["b1"])
return x, h, h @ P["W2"] + P["b2"]
def ztrata(P, X, y):
p = softmax(forward(P, X)[2])
return -np.mean(np.log(p[np.arange(len(y)), y]))
def gradienty(P, X, y):
x, h, logity = forward(P, X)
B = len(y)
dl = softmax(logity)
dl[np.arange(B), y] -= 1
dl /= B
g = {"W2": h.T @ dl, "b2": dl.sum(axis=0)}
dp = (dl @ P["W2"].T) * (1 - h ** 2)
g["W1"], g["b1"] = x.T @ dp, dp.sum(axis=0)
dx = (dp @ P["W1"].T).reshape(B, CTX, -1)
g["E"] = np.zeros_like(P["E"])
np.add.at(g["E"], X, dx)
return g
rng = np.random.default_rng(0)
D, H = 8, 48
P = {"E": rng.normal(0, 0.3, (V, D)),
"W1": rng.normal(0, 1 / np.sqrt(CTX * D), (CTX * D, H)), "b1": np.zeros(H),
"W2": rng.normal(0, 0.1, (H, V)), "b2": np.zeros(V)}
Xtr, ytr = okna(tr)
Xva, yva = okna(va)
print("krok trénink ověření")
for krok in range(6001):
lr = 0.5 if krok < 4000 else 0.1
i = rng.integers(0, len(Xtr), 64)
g = gradienty(P, Xtr[i], ytr[i])
for k in P:
P[k] -= lr * g[k]
if krok % 1500 == 0:
print(f"{krok:>4} {ztrata(P, Xtr, ytr):7.3f} {ztrata(P, Xva, yva):7.3f}")
def generuj(T, delka=64, seed=0):
r = np.random.default_rng(seed)
kontext = list(va[:CTX])
vystup = []
for _ in range(delka):
logity = forward(P, np.array([kontext]))[2][0]
j = r.choice(V, p=softmax(logity / T))
vystup.append(itos[j])
kontext = kontext[1:] + [j]
return "".join(vystup)
print()
for T in [0.3, 1.0, 2.0]:
print(f"T = {T}: {generuj(T)}")
krok trénink ověření 0 3.052 3.058 1500 0.296 0.288 3000 0.309 0.301 4500 0.287 0.291 6000 0.285 0.288 T = 0.3: kováře. žák hledá pekaře. žák vítá psa. kovář vidí pekaře. ková T = 1.0: kováře. žák hledá pekaře. žák vidí psa. pekař vidí žáka. kovář T = 2.0: klalřetátá žáka. koiář viří. včela vítá náka. vočka hledá kovář
Dívej se na tři řádky generovaného textu. Při nízké teplotě vznikají čisté a opakující se věty. Při T = 1 jsou věty správné, ale různorodé, protože model hraje podle toho, co se naučil. Při vysoké teplotě se začnou objevovat nesmysly: znak, který model považoval za nepravděpodobný, dostal šanci a dál se text tvoří z chyby.
Co jsi vlastně postavil? Všechny hlavní součásti velkého jazykového modelu: slovník a kódování, embeddingy, síť s nelinearitou, ztrátu křížovou entropií, ruční zpětný průchod, trénink minidávkami a generování s teplotou. Chybí jen jedna věc, a ta je klíčová.
Od okna k attention
Naše síť má okno pevné. Je to osm míst, každé má vlastní váhy v W1. Pokud chceš delší okno, matice roste a síť se musí učit každou pozici zvlášť. Důležité slovo vidí může stát na libovolném místě, ale síť ho pozná jen tehdy, když ho trénink ukázal přesně na té pozici.
Attention z lekce Attention od nuly to řeší tím, že každé místo v kontextu se může podívat na ostatní a vybrat si, co potřebuje. Váhy se počítají z obsahu, ne z polohy. Stejná sada vah se používá pro všechny pozice a délka kontextu není zabudovaná v maticích. A právě tohle je jádro transformeru z lekce Transformery.
Pod kapotou · mini-GPT v PyTorchi
Takhle by vypadal tentýž model s attention, v PyTorchi. Kód je jen ke čtení, PyTorch v prohlížeči nespustíš. Nad kontextem leží několik bloků transformeru s maskou, která zakáže dívat se do budoucnosti, a každý výstup dostane předpověď dalšího znaku. Trénuje se na všech pozicích najednou, což je i efektivnější než naše okna.
import torch
import torch.nn as nn
import torch.nn.functional as F
class MiniGPT(nn.Module):
def __init__(self, vocab, ctx=64, d=64, heads=4, vrstvy=2):
super().__init__()
self.tok = nn.Embedding(vocab, d)
self.pos = nn.Embedding(ctx, d)
blok = nn.TransformerEncoderLayer(d, heads, 4 * d, dropout=0.0,
batch_first=True, norm_first=True)
self.bloky = nn.TransformerEncoder(blok, vrstvy, enable_nested_tensor=False)
self.norma = nn.LayerNorm(d)
self.hlava = nn.Linear(d, vocab)
def forward(self, ids):
T = ids.shape[1]
x = self.tok(ids) + self.pos(torch.arange(T, device=ids.device))
maska = nn.Transformer.generate_square_subsequent_mask(T).to(ids.device)
x = self.bloky(x, mask=maska, is_causal=True)
return self.hlava(self.norma(x)) # (B, T, vocab)
model = MiniGPT(vocab=22)
opt = torch.optim.AdamW(model.parameters(), lr=3e-3)
for krok in range(2000):
X, y = davka() # y je X posunuté o jeden znak doleva
logity = model(X)
ztrata = F.cross_entropy(logity.reshape(-1, logity.size(-1)), y.reshape(-1))
opt.zero_grad()
ztrata.backward()
opt.step()Skutečné jazykové modely jsou stejný příběh, jen v jiném měřítku: slovník o desítkách tisíc tokenů místo 22 znaků, okno v desítkách až milionech tokenů a miliardy vah. Zbytek (ztráta, minidávky, generování s teplotou) je přesně to, co jsi dnes napsal.
Trénovací smyčka
Doplň tři chybějící kroky jedné minidávky: výběr vzorků, výpočet gradientu a posun vah.
Slož krok tréninku
Slož jeden krok minidávkového tréninku ve správném pořadí.
Který pojem k čemu patří?
Spoj pojem s tím, co dělá v modelu.
Co si odnést z mise
Vyzkoušej si: Kam se model dívá
Každý řádek ukazuje, kam se jeden token dívá. Porovnej to s pevným oknem naší sítě, které se dívá na všechny pozice stejně.