Mały GPT: blok z N12, który się uczy

W lekcji 12 kursu NN blok transformera miał losowe wagi i niczego nie umiał. Tu ten sam rodzaj bloku, ułożony jak w GPT-2 (normalizacja przed uwagą i MLP) i z maską, uczy się: dostaje tekst Atlasu po polsku i przewiduje następny znak. To pierwszy model w tym kursie, który jest siecią neuronową i naprawdę się trenuje. Obok stoi model, który tylko zlicza trójki znaków. Sprawdzimy uczciwie, który wypada lepiej.

Spróbuj

• Przesuwaj suwak kroków od 100 w prawo i patrz na dwie krzywe: walidację i trening. Gdzie walidacja przestaje spadać, choć trening dalej spada?
• Przełącz na „bez kodowania pozycji” i porównaj krzywe przy 3200 krokach. Potem sprawdź to samo na innych startach.
• Naciśnij „Trenuj od nowa” przy 300 krokach i napisz 40 znaków. Porównaj licznik przejść w treningu i w pisaniu.

Pomysł w prostych słowach

Model dostaje okno 16 znaków i dla każdej pozycji zgaduje, jaki znak jest następny. Maska przyczynowa sprawia, że pozycja 5 widzi tylko znaki 1–5, nigdy dalsze. Dzięki temu jedno przejście przez blok daje 16 uczciwych przewidywań naraz i 16 składników straty. W labie paczka ma 8 okien, więc jeden krok Adama to 8 przejść i 128 przewidywań, a 300 kroków to 2400 przejść i 38 400 przewidywań.

Pisanie tak nie działa. Następny znak zależy od poprzedniego, a ten trzeba najpierw wybrać. Dlatego model pisze po jednym znaku: 40 nowych znaków to 40 przejść przez blok.

Perpleksja to exp ze średniej entropii krzyżowej (lekcja 4 kursu NN). Mówi, spośród ilu równie prawdopodobnych znaków model zgaduje. Model bez żadnej wiedzy zgadywałby spośród 34 znaków, czyli wszystkich liter, spacji i kropki.

Dlaczego to działa

Strata to średnia entropia krzyżowa po wszystkich pozycjach paczki. Propagacja wsteczna i Adam z kursu NN robią resztę. W labie forward i backward są napisane ręcznie, bez biblioteki, a niezależne lustro w numpy daje te same liczby: na pięciu startach przez 400 kroków, a na starcie 1 przez całe 6400.

Krzywe pokazują, co robi trening na małym tekście. Na starcie 1 walidacja jest najniżej po 3200 krokach (8,86), a po 6400 ma 9,54, choć trening dalej spada z 6,34 do 5,30. Na 4 z 5 startów walidacja jest najniżej przy 3200 krokach, na starcie 2 dopiero przy 6400. Pewne jest co innego: od 1600 kroków luka między tekstem odłożonym a treningiem rośnie z każdym punktem, na walidacji i na teście, na każdym z pięciu startów. Model coraz lepiej zna tekst treningowy niż nowy. Czy dalsze kroki już szkodzą, tego ta zabawka nie rozstrzyga: walidacja i test mają po ok. 500 znaków, a od 3200 do 6400 kroków test spada na 4 z 5 startów. Procedura zostaje ta sama: liczbę kroków wybierasz na walidacji, test oglądasz raz, na końcu.

Czy sieć w ogóle dogania zliczanie? Uczciwie sprawdza to test: na każdym starcie bierzesz krok z najniższą walidacją i raz liczysz perpleksję na teście. Sieć ma wtedy od 9,32 do 10,17, a model 3-gramowy 8,26: zliczanie wygrywa na każdym z pięciu startów. Na samej walidacji najlepszy punkt sieci bywa poniżej 3-gramu, ale tam wybierasz krok i porównujesz na tym samym tekście, więc sieć ma przewagę wyboru. Na 5775 znakach zliczanie wystarcza.

Mały GPT ma 4626 wag. Najmniejszy model z otwartej rodziny Pythia ma 70 mln parametrów, a największy 12 mld ^[3]. Ten najmniejszy jest więc ok. 15 tys. razy większy od zabawki. Liczb perpleksji z labu nie przenosimy na prawdziwe modele: inny tekst, inny tokenizator, inna skala.

Pozycje i maska

Bez kodowania pozycji uwaga bez maski widzi tylko zbiór słów (lekcja 12 kursu NN). Z maską jest inaczej: pozycja widzi tylko tekst przed sobą, a to zdradza, gdzie stoi. Duże modele bez kodowania pozycji wypadają podobnie do modeli z kodowaniem; autorzy przypuszczają, że maska pozwala tokenowi policzyć, ilu ma poprzedników ^[2]. W labie tak nie jest. Bez kodowania pozycji jeden blok wie, jaki znak stoi na bieżącej pozycji, ale nie wie, który znak stał tuż przed nim. Przestaw znaki przed pozycją, a jej przewidywanie się nie zmieni. Po 3200 krokach ma na walidacji od 10,41 do 10,99, a z kodowaniem od 8,63 do 9,47, na każdym z pięciu startów. Tyle co model, który zlicza tylko pary znaków: 10,59. Jeden blok to za mało, żeby z samej maski odtworzyć kolejność: liczbę poprzedników musiałby najpierw policzyć, a potem jeszcze jej użyć.

import numpy as np

T, d = 16, 4
X = np.sin(np.arange(T * d).reshape(T, d))      # 16 positions, 4 numbers each (any fixed values)

def attend(X):                                 # one head with W_Q = W_K = W_V = I and the causal mask
    S = X @ X.T / np.sqrt(X.shape[1])
    S = S + np.triu(np.full(S.shape, -np.inf), 1)   # position t sees only positions 0…t
    A = np.exp(S - S.max(axis=1, keepdims=True))
    return (A / A.sum(axis=1, keepdims=True)) @ X

once = attend(X)                               # one pass over the window: all 16 positions
alone = np.array([attend(X[:t + 1])[t] for t in range(T)])   # 16 passes, each on the text up to t
print("one pass = 16 separate passes:", np.allclose(once, alone))
print("passes: training 16 positions =", 1, "| writing 16 characters =", T)

p_true = np.array([0.30, 0.05, 0.12, 0.20])    # probabilities the model gave the true next characters
print(f"perplexity = exp(mean cross-entropy) = {np.exp(-np.log(p_true).mean()):.2f}")
print(f"Pythia 70M / tiny GPT: {70_000_000 / 4626:.0f}x")

one pass = 16 separate passes: True
passes: training 16 positions = 1 | writing 16 characters = 16
perplexity = exp(mean cross-entropy) = 7.26
Pythia 70M / tiny GPT: 15132x