Transformer: klocki, które już znasz

Transformer to sieć, na której stoją dzisiejsze modele językowe. Nie ma w nim nowej magii. Składa się z klocków, które znasz z tego kursu: osadzeń i uwagi z lekcji 11, skrótu z lekcji 7, MLP z lekcji 2 i softmaksu z lekcji 4. Model to wiele takich samych bloków ułożonych jeden na drugim.

Spróbuj

• Najpierw ułóż blok. Dwa klocki to pułapki z innych lekcji. Przy każdym klocku jest link do lekcji, w której go poznałeś.
• Gdy blok jest ułożony, policzy oba zdania naraz. Wyłącz kodowanie pozycji i porównaj wiersze A i B przy każdym etapie.
• Potem przełącz na zdania o psie. Sprawdź, czy blok rozróżnia je bez kodowania pozycji.

Pomysł w prostych słowach

Blok robi dwie rzeczy na zmianę. Uwaga zbiera informację od innych słów: każde słowo bierze ważoną średnią wszystkich. MLP przerabia potem każde słowo osobno, tymi samymi wagami dla każdego. Wokół obu jest skrót: wynik dodaje się do wejścia, a potem normalizacja warstwy sprowadza każdy wektor do średniej 0 i wariancji 1, a potem mnoży go i przesuwa wyuczonymi wagami γ i β (w labie ich nie ma). Tak ułożył blok pierwszy transformer z „Attention Is All You Need”: normalizacja po skrócie (post-LN). GPT-2, Llama i większość dzisiejszych modeli normalizują przed uwagą i MLP, x + uwaga(LN(x)), bo głęboki stos bloków uczy się wtedy stabilniej. Lab trzyma się pierwszego układu. Na końcu ostatniego bloku softmax zamienia wektor słowa na prawdopodobieństwa następnego słowa.

Uwaga wielogłowa to kilka uwag naraz, każda na swoim kawałku wektora. W labie wektor ma d = 8 liczb i 2 głowy po 4 wymiary, a MLP ma postać 8 → 16 → 8. Cały blok ma 576 wag. Wagi są losowe, bez treningu: lab pokazuje, co blok liczy, a nie, co umie.

Dlaczego to działa

Uwaga bez maski traktuje zdanie jak zbiór. Zamień dwa słowa miejscami, a jej wynik zamieni się tak samo i niczym więcej się nie zmieni. Dlatego do wektora każdego słowa dodaje się na wejściu kodowanie pozycji: wektor, który zależy tylko od miejsca w zdaniu. W labie „uderzyło” stoi w obu zdaniach w środku, więc na wejściu jest identyczne. Różnica pojawia się dopiero w uwadze, bo tam słowo patrzy na sąsiadów, a ci zamienili się miejscami.

Kodowanie sinusoidalne z pierwszego transformera to fale o różnych prędkościach. Iloczyn skalarny kodów dwóch pozycji zależy tylko od odległości między nimi. W widżecie poniżej przełącz na d = 512: sąsiad daje 249,1, pozycja o 5 dalej 189,6, a o 40 dalej 137,0, przy maksimum 256.

Ten interaktywny eksperyment działa w przeglądarce z włączonym JavaScriptem. Tekst wokół opisuje, co w nim widać. Mapa sinusoidalnego kodowania pozycji (pozycja × wymiar) i wykres iloczynu skalarnego: dla d = 512 sąsiad daje 249,1, odległość 5 – 189,6, odległość 40 – 137,0, niezależnie od pozycji.

Czy to tylko ten jeden start wag? Na pięciu startach bez pozycji różnica „uderzyło” między zdaniami wynosi poniżej 10⁻¹⁴, czyli zero z dokładnością zaokrągleń. Z pozycją różnica po uwadze waha się od 0,38 do 2,35.

Po polsku końcówki mówią więcej

Po angielsku „dog bites man” i „man bites dog” mają te same słowa. Po polsku „pies gryzie człowieka” i „człowiek gryzie psa” już nie: pies i psa, człowieka i człowiek to inne słowa. Blok rozróżnia je nawet bez pozycji. Na pięciu startach różnica „gryzie” po uwadze wynosi od 0,55 do 2,11. Kolejność sprawdza dopiero para z tymi samymi słowami, dlatego lab ma „auto” i „drzewo”: mianownik i biernik brzmią tu tak samo.

Dalej: kurs LLM

To ostatnia lekcja kursu. Tokeny i trening na ogromnym tekście są już w osobnym kursie „Modele językowe od środka”, a dostrajanie i RAG dochodzą tam po kolei. Przycisk „Dalej” na dole strony prowadzi do tego kursu.

import numpy as np

def pe(pos, d):                       # sinusoidal position code of the original transformer
    w = 1 / 10000 ** (np.arange(d // 2) * 2 / d)
    return np.stack([np.sin(pos * w), np.cos(pos * w)], axis=1).ravel()

p = pe(10, 512)
print("d = 512, distance 1, 5, 40:", " ".join(f"{p @ pe(10 + k, 512):.1f}" for k in (1, 5, 40)))

def attend(X, causal=False):          # one head with W_Q = W_K = W_V = I: softmax(X Xᵀ / √d) X
    S = X @ X.T / np.sqrt(X.shape[1])
    if causal:                        # the mask of a model that writes text: word i sees only words 0…i
        S = S + np.triu(np.full(S.shape, -np.inf), 1)
    A = np.exp(S - S.max(axis=1, keepdims=True))
    return (A / A.sum(axis=1, keepdims=True)) @ X

E = {"auto": [1.0, 0.2, -0.5, 0.3], "uderzyło": [0.1, 1.0, 0.4, -0.2], "drzewo": [-0.6, 0.3, 1.0, 0.5]}
a = np.array([E[w] for w in ["auto", "uderzyło", "drzewo"]])
b = np.array([E[w] for w in ["drzewo", "uderzyło", "auto"]])
print("no positions, B = A in reverse:", np.allclose(attend(b), attend(a)[::-1]))
P = np.array([pe(i, 4) for i in range(3)])
gap = np.linalg.norm(attend(a + P)[1] - attend(b + P)[1])
print(f"with positions, 'uderzyło' moves by {gap:.3f}")
gap = np.linalg.norm(attend(a, causal=True)[1] - attend(b, causal=True)[1])
print(f"causal mask, no positions, 'uderzyło' moves by {gap:.3f}")

d = 512, distance 1, 5, 40: 249.1 189.6 137.0
no positions, B = A in reverse: True
with positions, 'uderzyło' moves by 0.318
causal mask, no positions, 'uderzyło' moves by 0.847