Lekce 09 · 18 min čtení

Celý transformer blok

Poskládáme attention, feed-forward, reziduální spojení a normalizaci do jednoho bloku, ze kterého se stohováním stane transformer.

Úvod

Máme všechny součástky. Tokeny, embeddingy, poziční kódování, multi-head attention. Teď z nich složíme jeden transformer blok, hotový stavební dílek. A pak ukážeme tu nejhezčí věc na celé architektuře: ten dílek se dá stohovat. Polož pár bloků na sebe a máš transformer. Polož jich devadesát a máš velký jazykový model.

Do bloku patří dva nové kousky, které jsme zatím neviděli, plus dvě lepidla, co to drží pohromadě i do hloubky. Pojďme na ně.

Voják skládá stejné bedny na sebe a důstojník kontroluje, jestli stojí rovně — Stejný dílek jde položit znovu a znovu. Hlavně ať se věž nerozjede.

Co v bloku ještě chybí

Attention umí jednu věc: zamíchat informaci mezi tokeny. Jenže potřebujeme i druhý pohyb: nechat každý token, ať si tu nasbíranou informaci v klidu zpracuje sám pro sebe. Od toho je feed-forward síť (zkratkou MLP).

Je to obyčejná malá síť z lekce 4, akorát se pustí na každý token zvlášť. Typicky rozšíří rozměr (třeba čtyřnásobně), prožene to nelinearitou a stáhne zpátky. Attention je „rozhlédni se kolem", feed-forward je „a teď si to promysli". Tyhle dva kroky se v bloku střídají.

Dvě lepidla: reziduum a normalizace

Když chceš stavět hluboko, narazíš na dva problémy. Bloky na sebe poskládáš a ono se to buď přestane učit, nebo se to celé rozhází. Transformer to řeší dvěma triky.

Reziduální spojení. Místo výstup = vrstva(x) počítáme výstup = x + vrstva(x). Vrstva tedy nepřepisuje vstup, jen k němu přidává opravu. Původní informace má vždycky volnou cestu skrz, a gradient z lekce 5 má kudy téct i do hlubokých vrstev. Bez tohohle triku hluboké sítě prakticky nešlo trénovat.

Normalizace (LayerNorm). Před každou podvrstvou srovná čísla na rozumné měřítko, kolem průměru nula. Drží to hodnoty v uzdě, takže se nic nerozhoupe do nekonečna a učení je stabilní. Ber to jako pojistku proti tomu, aby čísla utekla.

Jak to do sebe zapadá

Blok jsou dvě podvrstvy za sebou, každá zabalená do normalizace a rezidua. Nejdřív attention, pak feed-forward:

x \leftarrow x + \text{Attention}(\text{LayerNorm}(x))

x \leftarrow x + \text{MLP}(\text{LayerNorm}(x))

Klikni si na jednotlivé fáze a projdi si, co dělají a jaký mají tvar:

TransformerDiagram · jeden blok zblízka

Klikni na kteroukoliv fázi a koukni, co dělá. Šipky vpravo jsou reziduální spojení.

Multi-head attention

Každý token si přimíchá informaci z ostatních tokenů v kontextu. Srdce z lekcí 7 a 8.

tvar: n × d → n × d

Všimni si toho nejdůležitějšího: vstup i výstup bloku mají stejný tvar n × d. To není detail, to je celý vtip. Protože se tvar nemění, můžeš výstup jednoho bloku rovnou nacpat na vstup dalšího. A to je transformer: stejný blok, mnohokrát za sebou.

V kódu

Složíme celý blok v numpy. Je v tom všechno z posledních lekcí: normalizace, multi-head attention, reziduum, feed-forward. A na konci ho pustíme čtyřikrát za sebou, abys viděl to stohování naživo. Klikni Run.

python · pyodide

import numpy as np
rng = np.random.default_rng(0)

n, d = 6, 12          # 6 tokenů, rozměr 12
H, dh = 3, 12 // 3    # 3 hlavy po 4
X = rng.normal(size=(n, d))

def layernorm(x):
  mu = x.mean(axis=1, keepdims=True)
  var = x.var(axis=1, keepdims=True)
  return (x - mu) / np.sqrt(var + 1e-5)

def softmax(z):
  z = z - z.max(axis=1, keepdims=True)
  e = np.exp(z)
  return e / e.sum(axis=1, keepdims=True)

def attention(Q, K, V):
  return softmax(Q @ K.T / np.sqrt(Q.shape[1])) @ V

def multihead(x):
  heads = []
  for _ in range(H):
      Wq = rng.normal(size=(d, dh)); Wk = rng.normal(size=(d, dh)); Wv = rng.normal(size=(d, dh))
      heads.append(attention(x @ Wq, x @ Wk, x @ Wv))
  return np.concatenate(heads, axis=1) @ rng.normal(size=(d, d))

def feedforward(x):
  W1 = rng.normal(size=(d, 4 * d)) * 0.1
  W2 = rng.normal(size=(4 * d, d)) * 0.1
  return np.maximum(0, x @ W1) @ W2          # rozšiř, ReLU, zase zúž

def block(x):
  x = x + multihead(layernorm(x))            # attention podvrstva + reziduum
  x = x + feedforward(layernorm(x))          # MLP podvrstva + reziduum
  return x

out = block(X)
print("vstup: ", X.shape)
print("výstup:", out.shape, " (stejný tvar -> jde stohovat)")

# Stohování: pusť to přes 4 bloky za sebou
y = X
for i in range(1, 5):
  y = block(y)
  print(f"po {i}. bloku: {y.shape}")

Pořád dokola stejný tvar (6, 12). To je ten důvod, proč jde brát výstup a strkat ho do dalšího bloku donekonečna. Reálné modely jen mají větší d, víc hlav a hlavně hodně bloků na sobě. GPT-2 jich má 12 až 48, ty největší modely přes sto. Ale jeden blok vypadá přesně takhle.

Cvičení

Cvičení · lekce9-cv1

Reziduální spojení počítá x + vrstva(x). Na vstupu je x = 5 a podvrstva vrátí 2. Co vyleze z rezidua?

Cvičení · lekce9-cv2

Na vstup bloku přijde tvar n × d = 6 × 12. Kolik sloupců (d) má výstup?

Cvičení · lekce9-cv3

Feed-forward typicky rozšíří rozměr 4×. Z d = 12 na kolik ve své skryté vrstvě?

Cvičení · lekce9-cv4

V diagramu nahoře proklikej fáze bloku. Která fáze ti přijde nejdůležitější a proč? Napiš jednou větou.

Shrnutí

Transformer blok = attention podvrstva a feed-forward podvrstva za sebou, každá zabalená do normalizace a rezidua.
Feed-forward (MLP) nechá každý token zpracovat nasbíranou informaci sám pro sebe. Attention míchá mezi tokeny, MLP přemýšlí uvnitř tokenu.
Reziduální spojení (x + vrstva(x)) drží tok gradientu a umožní hloubku.
LayerNorm srovná čísla na rozumné měřítko a stabilizuje učení.
Vstup i výstup mají stejný tvar n × d, takže se bloky dají stohovat. Transformer je jen N stejných bloků nad sebou.

Co bude příště

Teď už máme úplně všechno. Tokenizaci, embeddingy, pozice, attention, bloky, trénink. Zbývá to slepit do jednoho funkčního celku a pustit na opravdový text.

V Lekci 10 (Mini-GPT) poskládáme finální projekt: malý, ale kompletní GPT v nějakých 150 řádcích. Natrénujeme ho na Švejkovi a necháme ho generovat text, který zní jako Hašek. Bude to vyvrcholení celého kurzu.