Transformery a velké jazykové modely: architektura krok za krokem

Jazykový model a perplexita, blok transformeru s kauzální pozorností, MLP a rezidui, malý znakový transformer napsaný od nuly, srovnání s bigramem, naučená shoda podle rodu, generování s teplotou a cesta k modelům se stovkami miliard parametrů.

14 minut Matěj Žalmánek 2026-10-16

Série Základy AI Díl 70 z 83

Celá osnova série 83 z 83 témat hotovo

Co si odnesete

Co dělá jazykový model a jak vypadá blok transformeru.
Co přinese pozornost oproti modelu, který vidí jen předchozí znak.
Jak model generuje text a čím se liší od velkých jazykových modelů.

Co se hodí znát předem: Mechanismus pozornosti: jak se model naučí, kam se dívat, Embeddingy a word2vec: jak se slovo stane vektorem, Aktivace, inicializace a normalizace: drobnosti, na kterých hluboká síť stojí

ChatGPT, Claude, Gemini i Llama mají uvnitř tutéž architekturu: transformer. Popsal ji tým z Googlu v roce 2017 v článku s nenápadným názvem „Attention Is All You Need“ a do pár let vytlačila z jazyka skoro všechno ostatní. Velký jazykový model je v jádru transformer, který se naučil jedinou věc — předpovídat další kousek textu — na obrovském množství textu. V tomhle dílu postavíme transformer od nuly, v malém: model, který píše po znacích a má 11 tisíc parametrů místo stovek miliard. Principy jsou ale přesně stejné.

Navazuje na díly Mechanismus pozornosti, Embeddingy a Aktivace, inicializace a normalizace.

1. Jazykový model: předpověz další znak

Definice — jazykový model a perplexita

Nechť 𝒱 je konečná neprázdná množina tokenů (slovník; u nás 36 znaků). Jazykový model je předpis, který každé posloupnosti x₁, …, x_t−1 ∈ 𝒱 (t ≥ 1; pro t = 1 je posloupnost prázdná) přiřadí rozdělení pravděpodobnosti dalšího tokenu, tj. čísla P(v | x₁, …, x_t−1) pro v ∈ 𝒱 taková, že

P(v | x₁, …, x_t−1) ≥ 0 pro každé v ∈ 𝒱 a ∑_{v ∈ 𝒱} P(v | x₁, …, x_t−1) = 1.

Nechť x₁, …, x_T ∈ 𝒱, T ≥ 1, je text. Ztráta modelu na tomto textu (průměrná křížová entropie dalšího tokenu, v natech na token) a perplexita jsou

L = 1/T ∑_t=1^T −ln P(x_t | x₁, …, x_t−1), PP = e^L.

Model se učí tak, že se jeho parametry hledají, aby L na trénovacím textu byla co nejmenší. Platí

PP = 1/^T√∏_t=1^T P(x_t | x₁, …, x_t−1),

tedy perplexita je převrácená hodnota geometrického průměru pravděpodobností skutečných tokenů. Model, který v každém kroku volí rovnoměrně mezi k tokeny, má PP = k — proto se perplexita čte jako počet rovnocenných možností, mezi kterými model v průměru váhá.

Laicky řečeno

Našeptávač v telefonu, jen mnohem lepší. Kdo umí dobře odhadnout další slovo, musí rozumět gramatice, souvislostem i tomu, o čem se mluví — jinak by se trefoval špatně. Celá „inteligence“ velkých jazykových modelů vznikla jako vedlejší produkt téhle jednoduché úlohy.

L = 1/T ∑_t=1^T −ln P( x_t | x₁, …, x_t−1 ), perplexita = e^L

x₁, …, x_t−1: kontext — všechno, co model zatím viděl (u nás nejvýš posledních 24 znaků); jen z toho smí hádat
x_t: znak, který v textu skutečně následuje — správná odpověď je zadarmo přímo v textu, proto stačí obyčejný text bez ručního značkování
P: pravděpodobnost, kterou model tomuto znaku dal (softmax z jeho výstupu přes všech 36 znaků)
−ln: trest za překvapení: za jistou správnou odpověď (P = 1) nula, za P = 0,5 trest ln 2 ≈ 0,693, a když dal model skutečnému znaku skoro nulu, trest roste nade všechny meze; logaritmus navíc z násobení pravděpodobností celé věty udělá součet
L: průměrná ztráta v natech na znak (průměr přes všech T pozic, aby nezávisela na délce textu); e^L ji převede zpět na „počet rovnocenných možností“

Model, který dá každému z 36 znaků stejnou šanci, má L = ln 36 = 3,584 a perplexitu přesně 36.

Příklad — ztráta a perplexita na třech znacích

Model dal třem skutečným znakům pravděpodobnosti 0,5, 0,25 a 0,8:

L = −ln 0,5 − ln 0,25 − ln 0,8/3 = 0,693 + 1,386 + 0,223/3 = 2,303/3 = 0,768

perplexita = e^0,768 = 2,15 (= ∛2 · 4 · 1,25, geometrický průměr čísel 1/P)

Barvy odpovídají členům vzorce výše.

Perplexita 2,15 znamená, že model byl v průměru stejně nejistý, jako kdyby rovnoměrně hádal mezi zhruba dvěma znaky.

Učíme na větách z dílu o embeddinzích (král vládl v paláci, dcera si hrála na hřišti…), tentokrát po znacích: 85 997 znaků k učení, 13 815 jiných k vyhodnocení, abeceda o 36 znacích. Model vidí posledních 24 znaků.

2. Blok transformeru

Definice — blok transformeru (dekodér)

Nechť 𝒱 je slovník o V tokenech, d ∈ ℕ dimenze modelu, T_max ∈ ℕ největší délka kontextu, d_ff ∈ ℕ vnitřní šířka MLP a c₁, …, c_T ∈ 𝒱 vstupní tokeny, 1 ≤ T ≤ T_max. Vektory tokenů píšeme jako řádky. Parametry modelu jsou matice embeddingů E ∈ ℝ^V×d (řádek E[c] patří tokenu c), matice pozičních embeddingů P ∈ ℝ^T_max×d, parametry pozornosti, W₁ ∈ ℝ^d×d_ff, c₁ ∈ ℝ^d_ff, W₂ ∈ ℝ^d_ff×d, c₂ ∈ ℝ^d, W_out ∈ ℝ^d×V, b_out ∈ ℝ^V a parametry tří normalizací vrstvy. Transformer (dekodér s jedním blokem) spočte pro t = 1, …, T:

vstupní vektory x_t = E[c_t] + P[t] ∈ ℝ^d;
(h₁, …, h_T) = (x₁, …, x_T) + Attn(LN(x₁), …, LN(x_T)), kde Attn je kauzální vícehlavá sebepozornost (vícehlavá pozornost z dílu Mechanismus pozornosti s kauzální maskou níže — token t vidí jen tokeny 1, …, t) a LN je normalizace vrstvy (níže);
y_t = h_t + MLP(LN(h_t)), kde MLP(u) = ReLU(uW₁ + c₁)W₂ + c₂ a ReLU(r) = max(0, r) po složkách — MLP se použije na každou pozici zvlášť;
logity z_t = LN(y_t)W_out + b_out ∈ ℝ^V;
rozdělení dalšího tokenu P(c_t+1 = v | c₁, …, c_t) = softmax(z_t)_v pro v ∈ 𝒱.

Kroky 2 a 3 tvoří blok transformeru; hlubší model opakuje bloky s vlastními parametry a výstup y jednoho bloku je vstupem x dalšího. Náš model má jeden blok, V = 36, d = 32, T_max = 24, d_ff = 64 a 2 hlavy.

Laicky řečeno

Pozornost je porada: každý znak se podívá na předchozí a posbírá od nich, co potřebuje. MLP je přemýšlení o samotě: každý znak si posbírané zpracuje. Reziduální spojení („+“) znamená, že se původní informace nikdy neztratí, jen se k ní přidává — dálnice pro gradient z dílu o aktivacích. Kauzální maska zakazuje dívat se dopředu: při učení by jinak model „opisoval“ znak, který má předpovědět.

Náš transformer: jeden blok, dvě hlavy pozornosti, d = 32

x_t = E[c_t] + P[t]

E[c_t]: řádek matice embeddingů (36 × 32) pro znak c_t — naučený vektor, který říká, co to je za znak
P[t]: poziční embedding (24 × 32) — říká, kde znak stojí. Je nutný, protože pozornost je jen vážený součet a pořadí sčítanců nevidí: bez něj by poslední „l“ ve slově „sel“ i v nesmyslu „esl“ vidělo stejnou trojici znaků a model by obě slova nerozlišil
x_t: vstupní vektor tokenu t (modře ve schématu); sečtení místo spojení vedle sebe šetří dimenzi a síť si obě informace umí oddělit

h = x + Attn(LN(x)), y = h + MLP(LN(h)), z = LN(y) W_out + b_out

x: vstup bloku; přičítá se k výstupu pozornosti beze změny (reziduální spojení), takže blok se učí jen opravu a gradient má přímou cestu dolů
LN: normalizace vrstvy před každou částí — drží vektory v rozumném rozsahu, ať se učení nerozjede; dává se na vstup části, ne na reziduální cestu, aby ta zůstala čistá
Attn: kauzální vícehlavá pozornost (zeleně ve schématu) — jediné místo, kde si tokeny vyměňují informace
MLP: MLP(u) = ReLU(uW₁ + c₁)W₂ + c₂ s vnitřní šířkou 64 (jantarově ve schématu) — zpracuje každý token zvlášť; pozornost jen průměruje, nelinearitu a „přemýšlení“ dodává tahle část
z: logity: pro každou pozici 36 čísel, softmax z nich dá P(další znak) (fialově ve schématu)

Náš model má jeden blok; velké modely opakují první dva řádky desítkykrát, výstup jednoho bloku je vstupem dalšího.

Definice — normalizace vrstvy (LayerNorm)

Nechť d ∈ ℕ, d ≥ 1, γ, β ∈ ℝ^d jsou naučené parametry (na začátku γ = (1, …, 1), β = (0, …, 0)) a ε > 0 je malá konstanta (u nás ε = 10⁻⁵; brání dělení nulou). Pro vektor u = (u₁, …, u_d) ∈ ℝ^d označme jeho průměr a rozptyl složek

μ(u) = 1/d ∑_j=1^d u_j, σ²(u) = 1/d ∑_j=1^d (u_j − μ(u))².

Normalizace vrstvy je funkce LN : ℝ^d → ℝ^d se složkami

LN(u)_j = γ_j · u_j − μ(u)/√σ²(u) + ε + β_j, j = 1, …, d.

Na matici tokenů (řádek = token) se LN použije na každý řádek zvlášť. Před násobením γ a přičtením β mají tedy složky každého tokenu průměr 0 a rozptyl (téměř) 1. Na rozdíl od batch normalizace se průměr a rozptyl počítají přes složky jednoho tokenu, takže výsledek nezávisí na tom, co je v dávce.

Příklad (γ = 1, β = 0): u = (1; 2; 3; 6), μ = 3, σ² = 4 + 1 + 0 + 9/4 = 3,5, √3,5 = 1,871 (ε je proti 3,5 zanedbatelné) → LN(u) = (−2/1,871; −1/1,871; 0; 3/1,871) = (−1,069; −0,535; 0; 1,604).

Definice — kauzální maska

Nechť T ≥ 1 je počet tokenů a s_ij ∈ ℝ (i, j = 1, …, T) skóre pozornosti tokenu i vůči tokenu j, už vydělená √d_k. Kauzální maska nahradí skóre nad úhlopříčkou hodnotou −∞:

ŝ_ij = s_ij pro j ≤ i, ŝ_ij = −∞ pro j > i,

a kauzální pozornost spočte váhy softmaxem po řádcích z ŝ s konvencí e^−∞ = 0, tj. pro i = 1, …, T:

a_ij = e^s_ij/∑_m=1ⁱ e^s_im pro j ≤ i, a_ij = 0 pro j > i.

Token i tedy váží jen sebe a tokeny před sebou a jeho váhy dávají součet ∑_j=1ⁱ a_ij = 1.

Příklad: třetí token z pěti má skóre (už vydělená √d_k) (1; 0,5; 2; 3; 1). Poslední dvě patří budoucím tokenům a vypadnou: e¹ = 2,718, e^0,5 = 1,649, e² = 7,389, součet 11,756 → váhy (2,718/11,756; 1,649/11,756; 7,389/11,756; 0; 0) = (0,231; 0,140; 0,629; 0; 0). Bez masky by nejvíc váhy dostal čtvrtý token, tedy znak, který má model teprve předpovědět.

Díky masce se z jednoho úseku T znaků učí T předpovědí najednou: pozice t vidí přesně kontext x₁, …, x_t a hádá x_t+1. U nás d = 32 a 2 hlavy, takže každá hlava má d_k = 16 a skóre se dělí √16 = 4.

Model má 11 588 parametrů. Pod kapotou je malá automatická derivace: každá operace (násobení matic, softmax s maskou, LayerNorm…) si pamatuje, jak spočítat svůj gradient, a zpětné šíření projde výpočet odzadu — přesně jako PyTorch. Test kontroluje, že se gradienty shodují s numerickou derivací.

Příklad — odkud je 11 588 parametrů

embeddingy: E 36 × 32 + P 24 × 32 = 1 152 + 768 = 1 920

pozornost: W_Q, W_K, W_V, W_O po 32 × 32 + LN (γ, β) = 4 · 1 024 + 2 · 32 = 4 160

MLP: W₁ 32 × 64 + c₁ + W₂ 64 × 32 + c₂ + LN = 2 048 + 64 + 2 048 + 32 + 64 = 4 256

výstup: LN + W_out 32 × 36 + b_out = 64 + 1 152 + 36 = 1 252

celkem 11 588; síť bez pozornosti nemá druhý řádek: 11 588 − 4 160 = 7 428

def transformer(znaky, M):                        # znaky: indexy posledních ≤ 24 znaků
    T = len(znaky)
    x = M.E[znaky] + M.P[:T]                      # T × d: co je to za znak + kde stojí
    a = layer_norm(x, M.g1, M.b1)
    Q, K, V = a @ M.Wq, a @ M.Wk, a @ M.Wv
    hlavy = []
    for r in range(M.hlav):                       # každá hlava má svých d_k = d / hlav sloupců
        q, k, v = Q[:, r], K[:, r], V[:, r]
        S = q @ k.T / sqrt(d_k)
        S[j > i] = -inf                           # kauzální maska: nedívat se dopředu
        hlavy.append(softmax(S, po_radcich=True) @ v)
    h = x + spoj_vedle_sebe(hlavy) @ M.Wo         # reziduum kolem pozornosti
    b = layer_norm(h, M.g2, M.b2)
    y = h + relu(b @ M.W1 + M.c1) @ M.W2 + M.c2   # reziduum kolem MLP
    return layer_norm(y, M.g3, M.b3) @ M.Wout + M.bout   # T × 36 logitů

3. Učení a co přinese pozornost

Ztráta během učení (3 000 kroků po 4 úsecích); čárkovaně bigramový model transformer stejná síť bez pozornosti bigram

Model	ztráta na nových větách	perplexita
rovnoměrné hádání ze 36 znaků	3,584	36
četnost znaků (unigram)	3,068	21,5
předchozí znak (bigram)	1,947	7,0
síť bez pozornosti (7 428 parametrů)	1,994	7,3
transformer	0,532	1,7

Síť bez pozornosti vidí jen aktuální znak (a jeho pozici), takže je to v podstatě bigram — a taky ho jen dorovná. S pozorností model vidí celé slovo a začátek věty a perplexita klesne ze 7,0 na 1,7: v průměru váhá jen mezi necelými dvěma možnostmi.

Definice — srovnávací modely: unigram a bigram

Nechť 𝒱 je abeceda o V znacích, x₁, …, x_N ∈ 𝒱 trénovací text a α > 0 vyhlazovací konstanta (u nás α = 0,1). Pro a, b ∈ 𝒱 označme

C(b) = |{t ∈ {1, …, N} : x_t = b}|, C(a, b) = |{t ∈ {2, …, N} : x_t−1 = a ∧ x_t = b}|

počet výskytů znaku b a počet výskytů dvojice „a a hned za ním b“. Pro kontext x₁, …, x_t−1 a znak b ∈ 𝒱 jsou

unigram — jazykový model, který kontext ignoruje: P(b | x₁, …, x_t−1) = C(b) + α/N + α · V;
bigram — jazykový model, který z kontextu použije jen poslední znak a = x_t−1 (pro t ≥ 2): P(b | x₁, …, x_t−1) = P(b | a) = C(a, b) + α/∑_{c ∈ 𝒱} C(a, c) + α · V.

V obou případech je součet přes b ∈ 𝒱 roven 1 a díky α > 0 nemá žádný znak pravděpodobnost 0 (ztráta −ln 0 by byla nekonečná). Vzorec bigramu je rozebraný hned pod definicí.

P(b | a) = C(a, b) + α/∑_c C(a, c) + α · V

C(a, b): kolikrát v trénovacím textu po znaku a následovalo b — čím častěji, tím pravděpodobnější
∑_c C(a, c): kolikrát se a objevilo vůbec (s nějakým následníkem) — dělením z počtů vzniknou podíly
α: vyhlazení, u nás α = 0,1: každá dvojice dostane „desetinu výskytu“ navíc, takže i v tréninku nevídaná dvojice má malou kladnou pravděpodobnost
V: počet znaků abecedy (36); α se přičetlo V-krát v čitatelích, proto musí být V-krát i ve jmenovateli, aby součet přes b zůstal 1

Příklad — co bigram ví po znaku „š“

V trénovacím textu je za „š“ 952 znaků, z toho „l“ 278krát a „e“ 299krát:

P(l | š) = 278 + 0,1/952 + 0,1 · 36 = 278,1/955,6 = 0,291

P(e | š) = 299 + 0,1/955,6 = 0,313

Barvy odpovídají členům vzorce výše.

Tytéž dvě čísla dá bigram po „princezna š“ i po „princ š“ — o rodu nemá jak vědět. Perplexitu z tabulky dostaneme jako e^ztráta: bigram e^1,947 = 7,00, transformer e^0,532 = 1,70.

4. Co se model naučil: shoda podle rodu

Konkrétní zkouška: dáme modelu text „osoba š“ a podíváme se, s jakou pravděpodobností doplní „l“ (tedy „šla“) místo „e“ („šel“). Aby se rozhodl správně, musí se podívat o několik znaků zpátky, na podmět.

Dvojice	P(„šla“) po mužském tvaru	P(„šla“) po ženském tvaru
muž / žena	3 %	95 %
král / královna	1 %	86 %
otec / matka	5 %	74 %
syn / dcera	6 %	93 %
chlapec / dívka	49 %	63 %
princ / princezna	1 %	68 %

V průměru čeká transformer „šla“ po ženských osobách s pravděpodobností 80 % a po mužských jen 11 %. Síť bez pozornosti rod nerozliší vůbec (26 % a 29 %): vidí jen „š“. Model ale není dokonalý — u dvojice chlapec/dívka váhá (49 % proti 63 %).

Příklad — rozdělení dalšího znaku po „princezna š“

Číslo v tabulce je jedna složka softmaxu z posledního řádku logitů: P(„l“) = e^z_l/∑_c e^z_c přes všech 36 znaků. Po „princezna š“ dává transformer

P(l) = 0,679, P(e) = 0,314, součet 0,993

síť bez pozornosti: P(l) = 0,281, P(e) = 0,259

Transformer skoro všechnu pravděpodobnost rozdělí mezi „šla“ a „šel“ — pozná, že za podmětem začíná sloveso. A které z nich, rozhoduje rod podmětu o několik znaků zpátky. Síť bez pozornosti zná jen „š“, a tak se chová podobně jako bigram (P(l | š) = 0,291, P(e | š) = 0,313).

Váhy pozornosti obou hlav pro text „princezna šla“ (řádek se ptá, sloupec odpovídá)

Váhy ukazují, že se hlavy většinou dívají jeden až tři znaky zpátky — sestavují si z nich slabiky a slova. Matice je trojúhelníková: nad úhlopříčkou nic není, to je kauzální maska.

5. Generování textu a teplota

Text se generuje znak po znaku: model spočte pravděpodobnosti dalšího znaku, jeden se vylosuje (s teplotou z dílu o softmaxu), přidá se na konec a opakuje se to. Začátek „královna “:

Teplota	vygenerovaný text
0	královna vládla v paláci a a seděla na trůnu. král vládla v paláci a a seděla n
0,5	královna vládla v paláci a a seděla na trůna ři. k obědu byl jablko a na talíři
1	královna vládla v paláci a ahrušel po ulice a lidi. král na hřišti jako a malý.
1,5	královna v paláci a achráce. muž šela po u aví česka má hranicekla ahoj. chlavn

S teplotou 0 (vždy nejpravděpodobnější znak) model opakuje své nejčastější věty — a i tak dělá chyby („a a“, „král vládla“): rod u slovesa, které je od podmětu daleko, se nenaučil vždycky. Kolem teploty 0,5–1 vznikají nové kombinace známých kousků. S teplotou 1,5 se text rozpadá na skoro-slova. Stejný knoflík mají i velké jazykové modely.

p_k = exp(z_k/τ)/∑_j exp(z_j/τ)

z_k: logit znaku k na poslední pozici — co model „navrhuje“; učil se s τ = 1
τ: teplota (v tabulce „Teplota“, ve vzorci τ, aby se nepletla s délkou textu T) — dělí rozdíly logitů: τ < 1 je zvětší a rozdělení zostří, τ > 1 je zmenší a rozdělení zploští; pro τ → 0 zbude jen nejpravděpodobnější znak
p_k: pravděpodobnost, s jakou se znak k vylosuje; součet přes všechny znaky je 1 pro každou teplotu

Teplota nemění pořadí znaků, jen jak moc má vítěz přednost: poměr dvou pravděpodobností při teplotě τ je jejich poměr při teplotě 1 umocněný na 1/τ.

Příklad — „princezna š“ při různých teplotách

Při teplotě 1 je P(l) = 0,679 a P(e) = 0,314, poměr 0,679/0,314 = 2,16. Protože p_k ∝ e^z_k (∝ znamená „rovná se až na kladný násobek, společný pro všechna k“), je exp(z_k/τ) = (e^z_k)^1/τ ∝ p_k^1/τ a stačí umocnit a znovu normalizovat:

τ = 0,5: poměr 2,16^2,00 = 4,68, p_l = 0,824, p_e = 0,176

τ = 1: poměr 2,16^1,00 = 2,16, p_l = 0,679, p_e = 0,314

τ = 1,5: poměr 2,16^0,67 = 1,67, p_l = 0,595, p_e = 0,355

Barvy odpovídají členům vzorce výše.

Při τ = 0,5 se „šla“ vylosuje skoro v pěti případech ze šesti, při τ = 1,5 už jen asi v 59 %.

def generuj(model, zacatek, delka, tau):
    text = zacatek
    for _ in range(delka):
        z = model(text[-24:])[-1]            # logity posledního znaku
        if tau == 0:
            k = argmax(z)                    # vždy nejpravděpodobnější
        else:
            p = softmax(z / tau)
            u = random()                     # rovnoměrně z [0, 1)
            k = 0
            while u > p[k]:                  # ruleta: znak k zabírá úsek délky p[k]
                u -= p[k]
                k += 1
        text += znaky[k]                     # přidat a pokračovat s delším textem
    return text

6. Od 11 tisíc ke stovkám miliard

Stejná architektura, jiné měřítko. GPT-2 (2019) měl 1,5 miliardy parametrů a 48 bloků, GPT-3 (2020) 175 miliard a 96 bloků — patnáctmilionkrát víc než náš model. Místo 24 znaků vidí tisíce až statisíce tokenů.
Tokeny místo znaků. Velké modely nepíšou po znacích, ale po kouscích slov — o tom je díl o tokenizaci.
Poziční informace. Místo naučených pozičních embeddingů se dnes používají rotace (RoPE), které lépe zvládají delší texty.
Učení. Předtrénování na bilionech tokenů trvá měsíce na tisících grafických karet; pak přichází doladění, aby z modelu, který doplňuje text, byl asistent. Obojí probírají další díly.

N ≈ n_bloků · ( 4d² + 8d² ) = 12 · n_bloků · d²

4d²: pozornost: matice W_Q, W_K, W_V, W_O, každá d × d (hlavy si jen dělí sloupce, počet parametrů nemění)
8d²: MLP: velké modely mají vnitřní šířku 4d, tedy d · 4d + 4d · d; MLP drží dvě třetiny parametrů
n_bloků: počet bloků nad sebou — každý má vlastní matice
N: počet parametrů bez embeddingů; posuny, LayerNorm a embeddingy jsou proti d² členům u velkých modelů zanedbatelné

Odhad, který používají Kaplan a kol. (2020, „Scaling Laws for Neural Language Models“). Náš model má vnitřní šířku MLP jen 2d, proto u něj vychází 8d² na blok.

Příklad — GPT-2, GPT-3 a náš model

GPT-2 (48 bloků, d = 1 600): 12 · 48 · 1 600² = 1,47 miliardy (uváděno 1,5 miliardy)

GPT-3 (96 bloků, d = 12 288): 12 · 96 · 12 288² = 174 miliard (uváděno 175 miliard)

náš model (1 blok, d = 32): 1 · (4 · 32² + 4 · 32²) = 8 192 v maticích bloku (MLP má u nás šířku 2d, proto 4d² místo 8d²); zbylých 3 396 z 11 588 jsou embeddingy, výstupní vrstva, posuny a LayerNorm — u malého modelu nejsou zanedbatelné

Barvy odpovídají členům vzorce výše. Rozměry jsou z článků Radford a kol. (2019) a Brown a kol. (2020). Výpočetní cena učení se odhaduje na 6N operací na token (dopředný průchod 2N, zpětný asi 4N); GPT-3 se učil na 300 miliardách tokenů, tedy 6 · 175 · 10⁹ · 300 · 10⁹ ≈ 3,15 · 10²³ operací — Brown a kol. uvádějí 3,14 · 10²³.

7. Shrnutí

Jazykový model předpovídá další token; učí se křížovou entropií na velkém textu.
Blok transformeru = kauzální vícehlavá pozornost + MLP, obojí s reziduálním spojením a normalizací vrstvy.
Náš transformer s 11 588 parametry dosáhl perplexity 1,7; bigram 7,0 a stejná síť bez pozornosti 7,3.
Pozornost mu dovolila naučit se shodu podle rodu: „šla“ po ženských osobách 80 %, po mužských 11 %.
Generuje se znak po znaku a teplota řídí, jak odvážně; velké modely jsou totéž ve větším.

Chcete si to osahat? Nechte AI agenta napsat tento transformer v PyTorchi (je to asi sto řádků, třeba podle Karpathyho „nanoGPT“) a naučit ho na vaší oblíbené knize — a sledujte, jak se s počtem kroků zlepšuje text.

Máte na to jiný názor? Napište na support@coden-app.com.

Transformery a velké jazykové modely: architektura krok za krokem

1. Jazykový model: předpověz další znak

2. Blok transformeru

3. Učení a co přinese pozornost

4. Co se model naučil: shoda podle rodu

5. Generování textu a teplota

6. Od 11 tisíc ke stovkám miliard

7. Shrnutí

Agent na vašem počítači, ovládaný z telefonu