0 dní v řadě · 0 bodů

Neuronové sítě a moderní AI · 55 min

Mise: znakový jazykový model

Postavíš v NumPy malý jazykový model od nuly: slovník, bigramy, síť s kontextem a vlastním zpětným průchodem, teplotu a generování textu. A uvidíš, proč velké modely potřebují attention.

Hloubka
Úkoly
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."])
Výstup
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

Ú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 {}, {}
Výstup

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))
Výstup
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

Ú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
Výstup
Kvíz

Bigram dosáhl na ověřovacích datech skoro stejné ztráty jako na trénovacích. Co z toho plyne?

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ů:

text
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 E př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)}")
Výstup
 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.

Najdi chybu

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

Ú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)
Výstup

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}")
Výstup
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.

Kvíz

Síť s oknem 2 znaky má vyšší ověřovací ztrátu než síť s oknem 8. Který důvod je správný?

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 < 1 rozdíly zesílí, pravděpodobné znaky vyhrávají a text je opatrný a opakující se,
  • T = 1 je to, co se model naučil,
  • T > 1 rozdí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

Ú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))
Výstup

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)}")
Výstup
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.

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

Doplň

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ž kód

Slož krok tréninku

Slož jeden krok minidávkového tréninku ve správném pořadí.

Spoj dvojice

Který pojem k čemu patří?

Spoj pojem s tím, co dělá v modelu.

Kartičky

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