Jak działają Transformers – od wąskich gardeł RNN po uwagę, agenty i okna kontekstowe
Krok po kroku: przegląd transformera – dlaczego RNNs utknęły w rozwoju, jak działają tokeny i embeddingi, uwaga, QKV, głowy przetwarzania, pozycje, struktura bloków, skalowanie oraz agenci.
Każdy, kto korzysta wyłącznie z narzędzi AI, może sobie poradzić bez znajomości tego, co działa w tle. Każdy, kto chce budować, debugować lub rozwijać te systemy, nie może tego zrobić. Każdy powszechnie używany model językowy opiera się na jednej architekturze, przedstawionej w artykule z 2017 roku liczącym około piętnastu stron pod tytułem „Attention Is All You Need”. Niewiele artykułów badawczych z ostatniej dekady tak bardzo zmieniło kierunek rozwoju sztucznej inteligencji. Idee leżące u jej podstaw nie są tak przerażające, jak mogłoby się wydawać, a arytmetyka staje się zrozumiała, gdy jest przedstawiona we właściwej kolejności. Potem te same idee pojawiają się wszędzie: w sposobie planowania przez agenty, w tym, dlaczego działa uczenie się w kontekście, w tym, dlaczego model może przechodzić między tematami w trakcie rozmowy, oraz w tym, dlaczego dłuższe okna kontekstowe są tak ważne.
Opisany poniżej szlak zaczyna się od starego, sekwencyjnego podejścia i przyczyn jego załamania, omawia, jak tekst przekształca się w liczby, następnie skupia się na mechanizmie uwagi i pełnej strukturze bloków, a kończy na tym, jak to rozwiązanie rozwinęło się w dzisiejsze modele językowe i agenty.
Dlaczego czytanie tekstu słowo po słowie napotkało bariery
Przed pojawieniem się transformatorów język był przetwarzany głównie za pomocą sieci neuronowych rekurencyjnych, zwykle skracanych do RNN. Koncepcja jest prosta – sieć przegląda sekwencję słowo po słowie, przenosząc dalej ukryty stan, który stanowi podsumowanie wszystkiego, co zostało dotychczas zobaczone.
Opis sytuacji: ktoś czyta powieść, ale może zachować tylko jedną notatkę, musi czytać stronę po stronie, nie mogąc przeskakiwać do przodu ani cofać się. Po każdym zdaniu notatkę przepisuje się, zapisując to, co wydaje się ważne, ale notatka jest mała. Do strony 300 prawie nic z pierwszej strony nie zostaje. Niemożliwe jest również przekazanie drugiego rozdziału przyjacielowi do jednoczesnego czytania, ponieważ najpierw trzeba ukończyć notatki z pierwszego rozdziału.
Taki ścisły porządek powoduje dwa oddzielne problemy z skalowalnością.
Pierwszym z nich jest zanikający gradient. Szkolenie sieci odbywa się poprzez backpropagację, która określa, w jakim stopniu każdy parametr przyczynił się do błędu. W RNN czytającym długą sekwencję ten sygnał musi przemieszczać się wstecz przez każdy krok czasowy. Zanim dotrze do najwcześniejszych kroków, często już prawie zanika, więc sieć faktycznie nie może uczyć się na podstawie tych wczesnych słów.
Drugim problemem jest wąskie gardło sekwencyjne. Wynik w pozycji n nie może zostać obliczony przed zakończeniem przetwarzania pozycji n-1, ponieważ każdy krok wykorzystuje poprzedni stan ukryty. Nowoczesne karty graficzne są zaprojektowane do wykonywania ogromnej liczby operacji jednocześnie, a RNN nie dają im praktycznie nic do zrobienia równolegle. Dokument składający się z 1000 słów wymaga 1000 kolejnych kroków, przy czym sprzęt jest w większości czasu nieużywany pomiędzy nimi.
Poniższy diagram porównuje dwa sposoby obsługi tokenów: po jednym z stopniowym zanikaniem stanu ukrytego z jednej strony oraz połączeniem każdej pary tokenów jednocześnie z drugiej strony:
╔══════════════════════════════════════════════════════════════════════════════╗
║ RNN vs TRANSFORMER: HOW TOKENS ARE PROCESSED ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ RNN ── Sequential (slow, forgets early context) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ║
║ │ │ │ │ │ │ ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ RNN │──▶│ RNN │─▶│ RNN │▶│ RNN │▶│ RNN │▶│ RNN │ ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ h₁ ──▶ h₂ ──▶ h₃ ──▶ h₄ ──▶ h₅ ──▶ h₆ ║
║ ║
║ Step 1 Step 2 Step 3 Step 4 Step 5 Step 6 (must wait!) ║
║ ⚠ "The" signal is diluted through 5 hops by the time we reach "mat" ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ TRANSFORMER ── Parallel (fast, every token sees all others) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ◀── ALL AT ONCE ║
║ │╲╲ │╲ ╲╲ │╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ │ ╲╲ │ ╲ ╲╲ │ ╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ ├───╫──┼───╫───┼───╫───┼────╫──┼────╫───┤ ← every token ║
║ │ ╱╱ │ ╱ ╱╱ │ ╱╱ ╱ │ ╱╱ │ ╱╱ │ attends to ║
║ │╱╱ │╱ ╱╱ │╱╱ ╱ │ ╱╱ │ ╱╱ │ every token ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ out │ │ out │ │ out │ │ out │ │ out │ │ out │ ← all computed ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ simultaneously ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ ✓ "The" has DIRECT connection to "mat" — no information decay ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ LEGEND: ──▶ sequential dependency ╲╱╱ all-pairs attention ║
║ h₁ hidden state ⚠ information bottleneck ║
╚══════════════════════════════════════════════════════════════════════════════╝
Bramki pomagały, ale nie zmieniły charakteru problemu
Sieci pamięci krótko- i długoterminowej, wprowadzone przez Hochreitera i Schmidhubera w 1997 roku, dodawały bramki, umożliwiając wyraźną kontrolę nad tym, co zachować, co usunąć i co wygenerować na każdym kroku. Działały dobrze. W latach 2010. były wykorzystywane w większości praktycznych zastosowań w dziedzinie NLP, w tym we wczesnym tłumaczeniu maszynowym, analizie nastrojów i generowaniu tekstu.
Mimo to pozostały sekwencyjne. Bardzo dalekie zależności wciąż stanowiły wyzwanie, a sprzęt równoległy nie mógł być w pełni wykorzystany. LSTM nie zawiodły dlatego, że źle modelowały język. Poddawały się z powodu braku możliwości skalowania: zwiększanie mocy obliczeniowej przynosiło coraz mniejsze efekty, a przezwyciężenie tego ograniczenia wymagało zupełnie innego stylu obliczeń.
Z tekstu na liczby
Sieci neuronowe przetwarzają liczby, a język składa się ze słów, dlatego konieczna jest konwersja przed tym, jak uwaga zostanie skierowana na treść. Proces ten polega na dwóch krokach: tokenizacji i embeddingu.
Tokenizacja
Tokenizacja przekształca ciąg znaków w sekwencję identyfikatorów całkowitych zaczerpniętych z ustalonej słowniczki. Najważniejsze jest zrozumienie, że tokeny to nie słowa. Współczesne narzędzia do tokenizacji dzielą tekst na fragmenty poniżej poziomu słów, zwykle przy użyciu Byte-Pair Encoding lub WordPiece, a wyniki wyglądają w ten sposób:
"Hello world" → ["Hello", " world"] → [15496, 995]
"unbelievable" → ["un", "believ", "able"] → [256, 9391, 540]
"ChatGPT" → ["Chat", "G", "PT"] → [14126, 38, 2969]
"antidisestablishmentarianism" → ["ant", "idis", "est", "ablish", "ment", "ari", "an", "ism"]
Słowa często występujące otrzymują własny token, natomiast rzadkie lub złożone słowa są dzielone na mniejsze części. Dzięki temu uzyskuje się dobrą pokrycie przy zarządzalnej wielkości słownictwa, ponieważ nie ma potrzeby tworzenia wpisu dla każdego możliwego słowa. Wielkość słownictwa waha się od około 30 000 w przypadku BERT i 50 257 w przypadku GPT-2 do ponad 100 000 w nowszych modelach.
Praktyczne porównanie dla języka angielskiego: jeden token odpowiada mniej więcej trzem czwartym słowa, a jedno słowo to około 1,3 tokena. Powieść składająca się z 100 000 słów ma więc w przybliżeniu 133 000 tokenów, co ma znaczenie w sytuacjach, gdy obowiązują ograniczenia okna kontekstowego.
Embeddingi
Matryca embeddingowa, która ma jedną linię na każdą pozycję słownika i d_model kolumn, mapuje każdy identyfikator tokena na wektor gęsty. Aby uzyskać informacje o danym tokenie, wystarczy wybrać jego odpowiednią linię. Identyfikator tokena 995, oznaczający „world”, odnosi się do linii nr 995 i zwraca wartości z zakresu d_model, na przykład 0,24, -0,83, 0,17 itd., aż do 0,91.
Linię tę uczy się podczas treningu, i wtedy pojawia się przydatna właściwość: tokeny o powiązanych znaczeniach mają wektory, które są ze sobą geometrycznie bliskie.
Cosine similarity in embedding space:
similarity("cat", "lion") ≈ 0.89 ← very similar
similarity("cat", "moon") ≈ 0.12 ← not similar
similarity("king", "queen") ≈ 0.91 ← very similar
Jedna uwaga dotycząca słynnego przykładu: król minus mężczyzna plus kobieta równa się królowa. Ta arytmetyka pochodzi z Word2Vec z 2013 roku, a nie z embeddingów transformatorowych. Transformatory uczą się swoich embeddingów wspólnie ze wszystkimi innymi parametrami, więc prosta arytmetyka wektorowa jest mniej wiarygodna. To, co przetrwało, to zasada, że słowa o powiązanych znaczeniach zajmują sąsiednie obszary w tym przestrzeni.
Jedna szerokość wszędzie
Stała wymiara d_model występuje wszędzie w modelu typu transformer: w embeddingach, wynikach mechanizmu uwagi oraz wejściach i wyjściach warstw feed-forward. Jest to celowe rozwiązanie. Każdy komponent odczytuje i zapisuje dane do jednego strumienia wektorów o stałej szerokości, zwanego strumieniem resztkowym, który przepływa przez każdą warstwę. Ponieważ wszystkie komponenty pracują z wektorem o tej samej wielkości i dodają swoje wyniki z powrotem do niego, elementy te łączą się w sposób spójny. To również powód, dla którego informacje pozycyjne można po prostu dodać do embeddingu tokena – oba mają tę samą strukturę, a ich suma trafia bezpośrednio do strumienia.
Więc dane wejściowe do pierwszego bloku to embedding tokenów wraz z wektorem pozycji. Ponieważ oba znajdują się w tym samym przestrzeni, ich dodawanie nie wymaga dodatkowych parametrów, a informacje o pozycji są włączone do tych samych wektorów, które przenoszą znaczenie. Modele w stylu BERT, które analizują dwa zdania razem, jak w zadaniach z pytaniami i tekstem, dodają embedding segmentu, który wskazuje, do którego zdania należy dany token – 0 dla pierwszego i 1 dla drugiego. Modele w stylu GPT tego nie robią.
Uwaga: uczenie się, gdzie szukać
Mniej więcej w latach 2014 i 2015 badacze zajmujący się tłumaczeniem maszynowym zauważyli wadę nawet w systemach LSTM. Model wciskał wszystko, co wiedział o zdaniu wejściowym, do jednego wektora o stałej wielkości przed rozpoczęciem generowania wyniku, co stanowiło kolejną wąskość. Oczywistym pytaniem było, czy model może przy każdym kroku generacji spojrzeć na całe zdanie wejściowe. Odpowiedzią na to pytanie stał się mechanizm uwagi, który zmienił sposób modelowania sekwencji.
Dwie codzienne sytuacje sprawiają, że ta koncepcja staje się intuicyjna.
Na głośnej imprezie, gdzie toczy się dziesięć rozmów, mózg nie przyznaje każdemu dźwiękowi takiej samej wagi podczas śledzenia rozmowy z przyjacielem. Wzmacnia głos i kierunek pochodzące od przyjaciela, a resztę tłumi, nie wyłączając jej całkowicie. To wzmacnianie jest ciągłe, a nie polega na włączaniu i wyłączaniu.
Gdy dana jest fotografia klasowa i trzeba znaleźć nauczyciela, osoba ta nie analizuje każdego piksela w równym stopniu. Poszukiwania skupiają się bezpośrednio na cechach wskazujących na dorosłość, takich jak wzrost w porównaniu z innymi oraz proporcje twarzy. To, czego szuka się, kieruje ruchem oczu.
Obliczeniowa uwaga przekształca te intuicje w cztery kroki: mieć coś do poszukiwania, co stanowi zapytanie; mieć zbiór kandydatów, którzy mogą być istotni; przypisać każdemu kandydatowi ciągłą ocenę istotności; oraz połączyć te informacje, ważone według tych ocen.
Błędne przekonanie, które warto wyjaśnić od razu: uwaga nie oznacza, że model skupia się na jednej rzeczy i ignoruje wszystko inne. Wynikiem jest ważona średnia, do której przyczynia się każdy element, przy czym niektóre z nich przyczyniają się znacznie bardziej niż inne. To stopniowana ocena, a nie binarny fokus.
Oryginalna, dodana forma
W swojej pierwszej formie uwaga była dodatkiem do modeli RNN i LSTM. Na każdym kroku dekodowania model wykonywał następujące czynności:
- przyglądał się wszystkim ukrytym stanom kodera;
- obliczał wynik powiązania pomiędzy bieżącym stanem dekodera a każdym stanem kodera;
- przekształcał te wyniki w wagi za pomocą funkcji softmax;
- brał sumę wagową stanów kodera jako kontekst uwagi.
Softmax wymaga krótkiego wyjaśnienia. Przekształca wektor dowolnych liczb rzeczywistych w rozkład prawdopodobieństwa. Każdy wynik staje się wartością e wyprowadzoną do tej wartości, podzieloną przez sumę wartości e wyprowadzonych do wszystkich wyników. Wszystkie wyniki są dodatnie i ich suma wynosi 1, a ponieważ funkcja wykładnicza wyolbrzymia różnicę między dużymi a małymi wynikami, element o najwyższym wyniku otrzymuje największy udział w wagach.
To była duża poprawa, ponieważ model mógł teraz w każdym kroku dotrzeć do dowolnej części danych wejściowych. Następnie autorzy artykułu „Attention Is All You Need” postawili bardziej śmiałe pytanie: a co, jeśli usuniętoby mechanizmy rekurencyjne i uwaga nie byłaby czymś dodatkowym, lecz całym modelem?
Samouwaga i triada zapytania, klucza i wartości
Główną ideą artykułu z 2017 roku jest samouwaga. Zamiast skupiać się z jednej sekwencji na drugiej, każdy token w danej sekwencji skupia się na wszystkich pozostałych tokenach w tej samej sekwencji. W ten sposób transformery budują kontekst, a jego zrozumienie wymaga trzech wektorów obecnych w każdym obliczeniu uwagi: zapytania, klucza i wartości.
Motor wyszukiwania wideo
Wpisanie frazy „jak zrobić chleb pszenno-żytni” na stronie z filmami nie polega na porównywaniu tekstu z każdym kadrem każdego filmu. Każdy film posiada metadane w postaci etykiet, które pełnią rolę kluczy: tytuł, tagi, słowa kluczowe opisu. Strona porównuje zapytanie z tymi etykietami, aby uzyskać oceny trafności, a filmy o najwyższych wynikach są wyświetlane, aby można było uzyskać dostęp do ich rzeczywistej treści, czyli wartości.
W tym przypadku istnieje jedna ważna różnica. Rezultatem nie jest pojedynczy film, lecz ważona mieszanka wszystkich filmów jednocześnie, przy czym każdy z nich jest odtwarzany z głośnością proporcjonalną do jego trafności. Najbardziej istotny film dominuje, a cichsze elementy pozostałych filmów są dodawane jako warstwy poniżej. Mapowanie jest następujące:
| YouTube Concept | Attention Concept | Question it Answers |
|----------------|------------------|---------------------|
| Search query | **Query (Q)** | "What am I looking for?" |
| Video metadata/tags | **Key (K)** | "What do I contain?" |
| Actual video content | **Value (V)** | "What should I contribute?" |
Dlaczego trzy oddzielne wektory?
Dlaczego nie porównywać bezpośrednio embeddingów? Weźmy zdanie „Kot siedział na macie, ponieważ był zmęczony”. Aby ustalić, do czego odnosi się „on”, słowo to musi uwzględnić „kota”. W surowej przestrzeni embeddingów za to zaimki i rzeczowniki nie są szczególnie podobne. Podział na zapytania i klucze pozwala modelowi nauczyć się, że zapytanie zaimka powinno pasować do kluczy rzeczowników, do których może się odnosić, nawet jeśli zaimek i rzeczownik w swoich podstawowych embeddingach w ogóle nie przypominają się. Nauczona projekcja tworzy przestrzeń relewności, która jest oddzielna od przestrzeni podobieństwa surowych embeddingów. Relewność i podobieństwo to różne koncepcje, a projekt QKV umożliwia modelowi kodowanie obu.
Uwaga skalowana iloczynem skalarnym w czterech krokach
Pierwszym krokiem jest projekcja. Wkładka każdego tokena jest mnożona przez trzy nauczane macierze, W_Q, W_K i W_V, co daje zapytanie, klucz oraz wartość dla danego tokena.
Drugi krok mierzy zgodność. Pytanie brzmi, na ile dobrze token a pasuje do tokena b, a odpowiedzią jest iloczyn skalarny zapytania dla a z kluczem dla b. Wysoka wartość oznacza, że token a powinien zwrócić szczególną uwagę na token b. Iloczyny skalarne rosną wraz z rozmiarem wektora i wymiarem klucza d_k, a nie tylko kierunkiem, dlatego w następnym kroku są one skalibrowane.
Trzeci krok polega na skalowaniu i normalizacji. Gdy d_k jest duże, surowe iloczyny skalarne stają się dużymi wartościami i przesuwają funkcję softmax do obszarów, w których gradienty są bardzo małe. Dzielenie ich przez pierwiastek kwadratowy z d_k przed zastosowaniem softmax zapobiega temu, co dało metodzie nazwę „skalibrowana uwaga oparta na iloczynie skalarnym”. Rezultatem jest zbiór wag alpha_ab.
Czwarty krok to agregacja. Wynikiem dla tokena a jest suma, dla każdego tokena b, wartości alpha_ab pomnożonej wektorem wartości dla b.
Wszystkie tokeny można traktować razem jako macierze, w jednej zwięzłej formule: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Diagram ilustruje to na przykładzie trzywyrazowej frazy „the cat sat”:
╔══════════════════════════════════════════════════════════════════════════════╗
║ SCALED DOT-PRODUCT ATTENTION ── "the cat sat" ║
╚══════════════════════════════════════════════════════════════════════════════╝
STEP 1: Input embeddings - ALL tokens are stacked into one matrix X
┌─────────────────────────────────────────┐
│ "the"→x₁ "cat"→x₂ "sat"→x₃ │ X ∈ ℝⁿˣᵈ
└──────────────────┬──────────────────────┘
│ the SAME X feeds all three projections
STEP 2: Three separate linear projections (each applied to every token)
┌─────────────┴─────────────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ W_Q │ │ W_K │ │ W_V │ ← learned weight matrices
└────┬────┘ └────┬────┘ └────┬────┘
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Q rows │ │ K rows │ │ V rows │
│ q₁ │ │ k₁ │ │ v₁ │
│ q₂ │ │ k₂ │ │ v₂ │
│ q₃ │ │ k₃ │ │ v₃ │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
STEP 3: score = QKᵀ, scale by 1/√dₖ, then softmax row-wise
│ │ │
└──────┬──────┘ │
▼ │
┌─────────────────────┐ │
│ softmax(QKᵀ / √dₖ) │ │
│ the cat sat │ │
│ the[.72 .20 .08] │ │ each row
│ cat[.12 .71 .17] │ │ sums to 1.0
│ sat[.09 .28 .63] │ │
└──────────┬──────────┘ │
│ │
STEP 4: multiply weights by Values V (weighted sum)
└──────────┬─────────┘
▼
┌─────────────────┐
│ output for "cat"│ 0.12·v₁ + 0.71·v₂ + 0.17·v₃
└────────┬────────┘ ← rich context-aware vector
│
OUTPUT: contextualized token representations
┌──────────┐ ┌──────────┐ ┌──────────┐
│"the" │ │"cat" │ │"sat" │
│knows it │ │knows it │ │knows │
│precedes │ │sat, and │ │who was │
│"cat" │ │where │ │sitting │
└──────────┘ └──────────┘ └──────────┘
Przykład zastosowania: bank słów
Weźmy zdanie „Poszła do banku, aby wpłacić pieniądze”. Podczas gdy model transformacyjny koduje słowo „bank”, mechanizm samoudziału pozwala temu słowu jednocześnie badać wszystkie inne słowa. Duży ciężar jest przypisywany słowom „wpłacić” i „pieniądze”, co wpływa na reprezentację słowa „bank” poprzez dodanie znaczenia finansowego. Kontekst rozwiązuje tę niejednoznaczność.
╔══════════════════════════════════════════════════════════════════════════════╗
║ SELF-ATTENTION RESOLVES AMBIGUITY: What does "bank" mean? ║
╚══════════════════════════════════════════════════════════════════════════════╝
Sentence: "I went to the bank to deposit money"
t₁ t₂ t₃ t₄ t₅ t₆ t₇ t₈
ATTENTION WEIGHTS for token "bank" (t₅) attending to all other tokens:
Token │ Weight │ Visualization
──────────┼────────┼───────────────────────────────────────────
"I" │ 0.03 │ ░
"went" │ 0.04 │ ░
"to" │ 0.02 │
"the" │ 0.03 │ ░
"bank" │ 0.08 │ ░░
"to" │ 0.05 │ ░
"deposit" │ 0.38 │ ████████████████████████░░░░░░░░ ← strong!
"money" │ 0.37 │ ████████████████████████░░░░░░░ ← strong!
FULL ATTENTION HEATMAP (rows = query token, columns = key token):
Higher weight → more ░/▒/▓/█
Q\K │ I went to the bank to deposit money
──────────┼──────────────────────────────────────────────
I │ ▓ ░ ░ ░ ░ ░ ░ ░
went │ ░ ▓ ░ ░ ░ ░ ░ ░
bank │ ░ ░ ░ ░ ▒ ░ █ █ ← "bank"→"deposit","money"
deposit │ ░ ░ ░ ░ █ ░ ▓ ▒ ← "deposit"→"bank"
money │ ░ ░ ░ ░ █ ░ ▒ ▓ ← "money"→"bank"
BEFORE attention: "bank" = ambiguous (river bank? financial bank?)
AFTER attention: "bank" ≈ 0.38·v(deposit) + 0.37·v(money) + ...
→ "bank" representation is now strongly financial ✓
The model learned this WITHOUT any explicit disambiguation rules.
Masy pokazane na tym rysunku zostały sfabrykowane dla lepszej przejrzystości i nie pochodzą z rzeczywistego modelu. Rzeczywiste wzory zazwyczaj są bardziej chaotyczne, a badania nad tym, w jaki sposób masy uwagi odnoszą się do tego, co model „myśli”, wciąż trwają. Praktyczne korzyści są inne niż te przedstawione na obrazku: samouwaga dla wszystkich tokenów to mnożenie macierzy, czyli jedna operacja na GPU. To, co w RNN kosztuje n kroków sekwencyjnych, w transformatorze kosztuje jedną operację równoległą, i właśnie dlatego transformatory są skalowalne.
Liczne głowy, liczne perspektywy
Jedna jednostka oblicza naraz tylko jeden rodzaj powiązania, więc co się dzieje, gdy ważne są kilka różnych rodzajów relacji jednocześnie? Weźmy przykład „Muzyk, który wystąpił na festiwalu, zdobył nagrodę”. Aby to zrozumieć, trzeba jednocześnie śledzić kilka zależności: „zdobył” w powiązaniu z „muzykiem” jako podmiotem i orzeczeniem, „muzyk” z „wystąpił” poprzez zdanie względne, „wystąpił” z „festiwalu” jako miejscu wydarzenia, a „nagrodę” z „zdobył” jako orzeczeniem i dopełnieniem.
Jedna głowa musiałaby umieścić je wszystkie w jednym zestawie wag. Zamiast tego multi-head attention wykonywa funkcję uwagi h razy równolegle, za każdym razem z własnymi nauczonymi projekcjami dla zapytań, kluczy i wartości. Wyniki h obliczeń są łączone i przekazywane przez kolejną nauczoną macierz, W_O, która mapuje je z powrotem do wymiaru modelu. Każda głowa pracuje w mniejszym podprzestrzeni, przy czym d_k jest równa d_model podzielonej przez h, więc całkowity koszt obliczeń we wszystkich głowach jest mniej więcej taki sam jak w przypadku pojedynczej głowy o pełnej szerokości.
Wyobraź sobie rękopis wysłany do komitetu redakcyjnego. Redaktor gramatyczny sprawdza składnię, redaktor stylu analizuje tok narracji, sprawdzacz faktów szuka spójności semantycznej, a redaktor strukturalny obserwuje organizację na dłuższych dystansach. Wszyscy czytają jednocześnie i niezależnie, a ich notatki są łączone w jedną recenzję. Multi-head attention działa w ten sam sposób.
╔══════════════════════════════════════════════════════════════════════════════╗
║ MULTI-HEAD ATTENTION (3 heads shown) ║
╚══════════════════════════════════════════════════════════════════════════════╝
Input Embedding x ∈ ℝᵈ_model
┌────────────────────────────┐
│ [ x₁ x₂ x₃ ... xₙ ] │
└──────────┬─────────────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
▼ ▼ ▼
╔══════════════╗ ╔══════════════╗ ╔══════════════╗
║ HEAD 1 ║ ║ HEAD 2 ║ ║ HEAD 3 ║
║ "Syntax" ║ ║ "Semantics" ║ ║ "Position" ║
║ ║ ║ ║ ║ ║
║ W_Q¹ W_K¹ ║ ║ W_Q² W_K² ║ ║ W_Q³ W_K³ ║
║ W_V¹ ║ ║ W_V² ║ ║ W_V³ ║
║ ║ ║ ║ ║ ║
║ ┌──────────┐ ║ ║ ┌──────────┐ ║ ║ ┌──────────┐ ║
║ │ Scaled │ ║ ║ │ Scaled │ ║ ║ │ Scaled │ ║
║ │ Dot- │ ║ ║ │ Dot- │ ║ ║ │ Dot- │ ║
║ │ Product │ ║ ║ │ Product │ ║ ║ │ Product │ ║
║ │Attention │ ║ ║ │Attention │ ║ ║ │Attention │ ║
║ └────┬─────┘ ║ ║ └────┬─────┘ ║ ║ └────┬─────┘ ║
║ │ ║ ║ │ ║ ║ │ ║
║ learns: ║ ║ learns: ║ ║ learns: ║
║ subject-verb ║ ║ word meaning ║ ║ nearby-word ║
║ agreement ║ ║ similarity ║ ║ relationships║
╚══════╤═══════╝ ╚══════╤═══════╝ ╚══════╤═══════╝
│ head₁ ∈ ℝⁿˣ⁽ᵈ/ʰ⁾ │ head₂ │ head₃
└───────────────────┼───────────────────┘
▼
┌──────────────────────────────┐
│ CONCATENATE all heads │
│ [head₁ ║ head₂ ║ head₃] │ ∈ ℝⁿˣᵈ_model
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Final linear projection W_O │ blends info from all heads
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Multi-Head Attention Output │ ∈ ℝⁿˣᵈ_model (same shape as input)
└──────────────────────────────┘
Czym w końcu zajmują się głowy
Analizy wyszkolonych modeli wykazały istnienie głów, które się specjalizują. Niektóre zajmują się składnią, taką jak zgodność podmiotu i orzeczenia oraz modyfikatorami przypisanymi do rzeczowników. Inne działają na dużych odległościach, łącząc zaimki z ich antecedentami. Jeszcze inne są lokalne i skupiają się na sąsiednich słowach oraz wzorcach bigramowych. Niektóre rejestrują względną odległość między tokenami, a inne wyodrębniają role tematyczne, czyli określają, kto co zrobił komu. Nikt tego nie programuje – trening nagradza dokładne przewidywania, a sieć odkrywa, że podział zadań pomiędzy specjalizowanymi głowami jest skuteczny.
Ograniczenie tego podejścia: te kategorie pochodzą głównie z badań nad interpretowalnością mniejszych modeli. W dużych modelach wiele komponentów nie może być łatwo odczytanych, a eksperymenty pokazują, że takie modele często przetrwają usunięcie wielu komponentów z niewielką stratą jakości. Architektura umożliwia specjalizację, ale nie gwarantuje uporządkowanych, czytelnych dla człowieka podziałów.
Nadawanie słowom adresu
Samouwaga łączy każdą parę tokenów, ale przy tym traktuje sekwencję jak zbiór bez żadnego porządku. Wynik pomiędzy dowolnym tokenem a a tokenem b zależy wyłącznie od ich treści, a nie od tego, który pojawia się pierwszy czy jak daleko od siebie są umieszczone. Język jest silnie zależny od porządku. „Pies gryzie człowieka” i „Człowiek gryzie psa” zawierają te same słowa, ale oznaczają rzeczy przeciwne, a „nie jestem szczęśliwy” mówi coś zupełnie innego niż „szczęśliwy nie”. Ponieważ model typu transformer przetwarza wszystkie pozycje równolegle, nic w nim domyślnie nie koduje porządku, więc pozycja musi być wprowadzona wyraźnie. To właśnie jest zadaniem kodowania pozycyjnego.
Zastanów się nad dodawaniem metadanych do każdego budynku w mieście. Każdy z nich potrzebuje adresu, który określa jego lokalizację, wskazuje pozycję względną (budynek 402 znajduje się w pobliżu budynku 404) i pozwala na to bez konieczności wcześniejszej znajomości całego planu miasta. Koordynaty GPS robią to w sposób uporządkowany. Kodowanie pozycyjne to jego językowa wersja: współrzędna matematyczna dodawana do reprezentacji każdego słowa.
Fale sinusowe i kosinusowe
Pierwotny transformator wykorzystywał funkcje sinusoidalne, przy czym na każdą parę wymiarów embedowania przypadała jedna częstotliwość. Dla pozycji pos i indeksu wymiaru k wektor wypełniają sinusy i kosinusy wartości pos podzielone przez potęgę 10000, skalowane przez k. Powolne, niskoczęstotliwościowe fale wskazują na ogólną pozycję, natomiast szybkie, wysokoczęstotliwościowe fale na precyzyjną pozycję, a razem dają one każdej pozycji unikalny „odpis”.
╔══════════════════════════════════════════════════════════════════════════╗
║ SINUSOIDAL POSITIONAL ENCODING ║
╚══════════════════════════════════════════════════════════════════════════╝
GRID: exact values for a tiny d_model=8 - positions 0-4, dims 0-7
(frequency denominators are 1, 10, 100, 1000 for dim-pairs 0,1,2,3)
dim→ d=0 d=1 d=2 d=3 d=4 d=5 d=6 d=7
sin cos sin cos sin cos sin cos
pos↓ ──────────────────────────────────────────────────────
pos=0 │ 0.000 1.000 0.000 1.000 0.000 1.000 0.000 1.000 │
pos=1 │ 0.841 0.540 0.100 0.995 0.010 1.000 0.001 1.000 │
pos=2 │ 0.909 -0.416 0.199 0.980 0.020 1.000 0.002 1.000 │
pos=3 │ 0.141 -0.990 0.296 0.955 0.030 1.000 0.003 1.000 │
pos=4 │ -0.757 -0.654 0.389 0.921 0.040 0.999 0.004 1.000 │
↑ fast-changing ↑ medium-changing ↑ very slow
(high frequency) (mid frequency) (low freq)
unique per position gradual shift global structure
WAVE PATTERNS (each row = one dimension across positions):
dim 0 (sin): █ ▇ ▄ ▁ ▂ ▅ ▇ █ ▇ ▄ ▁ ← fast oscillation
dim 2 (sin): █ █ ▇ ▇ ▆ ▅ ▄ ▃ ▂ ▁ ▁ ← medium oscillation
dim 4 (sin): █ █ █ █ █ █ ▇ ▇ ▇ ▇ ▆ ← slow oscillation
dim 6 (sin): █ █ █ █ █ █ █ █ █ █ █ ← very slow oscillation
HOW IT'S USED: Added to the token embedding elementwise
┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│ Token Embedding│ │ Positional Enc. │ │ Final Input x_t │
│ "cat" │ │ position = 2 │ │ │
│ [0.2, 0.8, │ │ [0.9,-0.4, │ │ [1.1, 0.4, │
│ 0.1, 0.5, │ + │ 0.2, 1.0, │ = │ 0.3, 1.5, │
│ 0.9, 0.3] │ │ 0.0, 1.0] │ │ 0.9, 1.3] │
│ (meaning) │ │ (where in seq) │ │ (meaning+position)│
└─────────────────┘ └─────────────────┘ └──────────────────┘
WHY SINUSOIDS?
✓ Each position gets a unique encoding across all dimensions
✓ Distance between nearby positions is consistent and learnable
✓ Can represent any position mathematically (unlike learned embeddings)
✓ Model can attend to relative positions via linear combinations
Niższe wymiary oscylują szybko i rejestrują drobne szczegóły pozycji, natomiast wyższe wymiary zmieniają się powoli i rejestrują ogólny porządek. Wektor jest po prostu dodawany do embeddingu tokena.
Fiksyjne fale, nauczane tabele i rotacja
Schemat sinusoidalny ma przydatną właściwość matematyczną: kodowanie w pozycji pos+k jest funkcją liniową od kodowania w pozycji pos. Dzięki temu względne odchylenia są reprezentowane spójnie, co ułatwia naukę relacji pozycyjnych.
Używane przez BERT zaimplementowane embeddingi pozycji, czyli oddzielna tabela z jedną pozycją na wiersz, są prostsze, ale nie mogą ekstrapolować informacji na pozycje poza zakresem widzianym podczas treningu, podczas gdy sinusoidy w zasadzie mogą reprezentować dowolną pozycję. Mimo to sinusoidy nie rozwiązują w pełni problemu generalizacji na długie konteksty. Modele nadal mają trudności z sekwencjami znacznie dłuższymi od danych treningowych, ponieważ same wzorce uwagi muszą również być generalizowalne na nieznane odległości.
Modele takie jak Llama wykorzystują Rotary Position Embeddings, czyli RoPE. Przed obliczaniem iloczynów skalarnych zapytania i klucz są obracane o kąt proporcjonalny do ich pozycji. W iloczynie zapytania znajdującego się w jednej pozycji i klucza w innej, względne obrotowanie bezpośrednio koduje odstęp. Używanie względnej pozycji jako wyraźnego wejścia do oceny uwagi, zamiast czegoś domyślnego i uczonego poprzez macierze projekcji, pomaga w obsłudze długich kontekstów.
Pełna architektura
Teraz można połączyć wszystkie elementy. Diagram pokazuje nowoczesną wersję całej struktury z Pre-LayerNorm:
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ THE COMPLETE TRANSFORMER ARCHITECTURE (Pre-LayerNorm, modern) ║
╠═══════════════════════════════════════════╦═══════════════════════════════════════════╣
║ ENCODER (×N layers) ║ DECODER (×N layers) ║
╠═══════════════════════════════════════════╬═══════════════════════════════════════════╣
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ Linear → Softmax → P(next token) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ ⊕ Add (residual) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ FFN( LayerNorm(x) ) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ Encoder output → K, V (to decoder) ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ ⊕ Add (residual) │ ║
║ ┌───────────────────────────────────────┐ ║ └───────────────────────────────────────┘ ║
║ │ ⊕ Add (residual) │ ║ ▲ ║
║ └───────────────────────────────────────┘ ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ Cross-Attention │ ║
║ ┌───────────────────────────────────────┐ ║ │ Q ← decoder │ ║
║ │ FFN( LayerNorm(x) ) │ ║ │ K, V ← encoder output │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ ⊕ Add (residual) │ ║ │ ⊕ Add (residual) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Multi-Head Self-Attention │ ║ │ Masked Multi-Head Self-Attention │ ║
║ │ ( on LayerNorm(x), bidirectional ) │ ║ │ ( on LayerNorm(x), causal ) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Input Embedding + Positional Enc. │ ║ │ Output Embedding + Positional Enc. │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Source: "The cat sat on the mat" │ ║ │ Target (shifted): <BOS> "Le" "chat"… │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
╠═══════════════════════════════════════════╩═══════════════════════════════════════════╣
║ Data flows UPWARD (▲). Each sub-layer is a residual branch over a ║
║ LayerNorm-ed input: h = x + SubLayer( LayerNorm(x) ) ║
║ The encoder's output (K, V) flows into the decoder's Cross-Attention. ║
╚═══════════════════════════════════════════════════════════════════════════════════════╝
Transformator składa się z dwóch głównych części: kodera i dekodera. W oryginalnym artykule każda z nich miała 6 warstw, po 8 głowic uwagi oraz d_model równy 512.
Koder: rozumienie w kontekście
Koder analizuje sekwencję wejściową i tworzy uwarunkowaną kontekstem reprezentację każdego tokena, uwzględniając nie to, co słowo oznacza w izolacji, ale to, co oznacza w tym konkretnym zdaniu. Wykorzystuje dwukierunkową samouwagę, dzięki czemu każdy token może brać pod uwagę wszystkie pozostałe tokeny po obu stronach. W ten sposób rozwiązuje się powyższa niejednoznaczność słowa „bank”: model widzi jednocześnie „depozyt” i „pieniądze”.
Sześć warstw kodujących działa kolejno, z których każda udoskonala reprezentację. Wczesne warstwy skupiają się na aspektach składniowych, takich jak kolejność słów i rodzaj wyrazu. Warstwy środkowe zajmują się bardziej złożoną strukturą gramatyczną. Późniejsze warstwy uchwytują znaczenia wyższego poziomu, takie jak typy entytetów, struktura zdarzeń i aspekty pragmatyczne. To ułożenie warstw jest powodem tak dobrego działania metod transferu: drobna kalibracja dotyczy głównie późniejszych warstw, podczas gdy ogólne wzorce językowe w warstwach wczesnych pozostają przydatne w różnych zadaniach.
Dekodator: generowanie z wykorzystaniem pamięci
Dekodator wytwarza tokeny wynikowe jeden po drugim, w sposób autoregresyjny. Każdy nowy token zależy od wszystkiego, co zostało już wygenerowane, oraz od całego zakodowanego wejścia. Składa się on z trzech podwarstw.
Pierwszym rodzajem jest zamaskowana samoodpowiedzialność, nazywana również uwagą przyczynowo-skutkową. Dekoder może patrzeć tylko na tokeny, które już wygenerował, co jest wymuszone przez maskę przyczynowo-skutkową. Wartości powyżej linii diagonalnej są ustawiane na ujemną nieskończoność przed zastosowaniem funkcji softmax, co sprawia, że przyszłe tokeny stają się niewidoczne. W ten sposób trening odpowiada procesowi inferencji, ponieważ model musi przewidzieć każdy token wyłącznie na podstawie wcześniejszego kontekstu.
╔══════════════════════════════════════════════════════════════════════════╗
║ DECODER SELF-ATTENTION: Causal (Autoregressive) Masking ║
║ "Each token can only attend to itself and tokens before it" ║
╚══════════════════════════════════════════════════════════════════════════╝
Tokens: [The] [cat] [sat] [on] [mat]
t₁ t₂ t₃ t₄ t₅
ATTENTION SCORE MATRIX (row = query, col = key)
KEY → t₁ t₂ t₃ t₄ t₅
QUERY ↓ "The" "cat" "sat" "on" "mat"
──────────────────────────────────────
t₁ "The" │ ✓ ✗ ✗ ✗ ✗
t₂ "cat" │ ✓ ✓ ✗ ✗ ✗
t₃ "sat" │ ✓ ✓ ✓ ✗ ✗
t₄ "on" │ ✓ ✓ ✓ ✓ ✗
t₅ "mat" │ ✓ ✓ ✓ ✓ ✓
✓ = ALLOWED (score kept, participates in softmax)
✗ = MASKED (score → −∞, becomes 0 after softmax)
When generating t₃ "sat":
Raw scores: [ 2.1 3.4 1.8 -∞ -∞ ]
After softmax: [ 0.18 0.68 0.14 0 0 ]
↑
future tokens are invisible
WHY IS MASKING NECESSARY?
┌──────────────────────────────────────────────────────────┐
│ TRAINING: We feed the whole target sequence at once │
│ (teacher-forcing). Without masking, t₃ could "cheat" │
│ by looking at t₄ and t₅ - the answers it should │
│ be predicting. │
│ │
│ INFERENCE: We generate one token at a time anyway, │
│ so future tokens literally don't exist yet. Masking │
│ makes training match inference behavior exactly. │
└──────────────────────────────────────────────────────────┘
Drugim elementem jest cross-attention, most łączący encoder z dekoderem. Zapytania pochodzą od dekodera i reprezentują aktualny stan generowania, natomiast klucze oraz wartości pochodzą z encodera i odzwierciedlają treść wejścia. Taki jest mechanizm tłumaczenia. Gdy dekoder wytwarza francuskie słowo „chat”, wysyła zapytanie do reprezentacji całego angielskiego zdania w encoderze, a cross-attention kieruje większy nacisk na słowo „cat”.
Trzecim elementem jest sieć feed-forward, której rola jest identyczna z tą sieci w encoderze i została opisana poniżej.
Trzy rodziny zbudowane z tych samych elementów
Połączenie encodera z dekoderem to tylko jeden sposób wykorzystania tych komponentów, a różne zadania wymagają różnych układów:
| Model | Architecture | Training Objective | Best For |
|-------|-------------|-------------------|----------|
| **BERT** | Encoder-only | Masked Language Modeling | Understanding: classification, NER, QA |
| **GPT** | Decoder-only | Next token prediction | Generation: writing, coding, conversation |
| **T5** | Encoder-Decoder | Text-to-text seq-to-seq | Transformation: translation, summarization |
╔══════════════════════════════════════════════════════════════════════════════════════╗
║ BERT vs GPT vs T5: Architecture Families ║
╠══════════════════╦═══════════════════════════╦═════════════════════════════════════╣
║ BERT ║ GPT ║ T5 ║
║ Encoder-Only ║ Decoder-Only ║ Encoder + Decoder ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ ATTENTION: ║ ATTENTION: ║ ATTENTION: ║
║ t₁ ● ● ● ● ║ t₁ ● ║ Encoder: ● ● ● ● (bidir) ║
║ t₂ ● ● ● ● ║ t₂ ● ● ║ ● ● ● ● ║
║ t₃ ● ● ● ● ║ t₃ ● ● ● ║ Decoder: causal + ║
║ t₄ ● ● ● ● ║ t₄ ● ● ● ● ║ cross-attn to encoder ║
║ (bidirectional) ║ (causal/left-only) ║ ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ BEST FOR: ║ BEST FOR: ║ BEST FOR: ║
║ ✓ Classification ║ ✓ Text generation ║ ✓ Translation ║
║ ✓ NER / tagging ║ ✓ Completion ║ ✓ Summarization ║
║ ✓ Sentence embeds ║ ✓ Chat / dialogue ║ ✓ Question answering ║
║ ✓ Reading comp. ║ ✓ Code generation ║ ✓ Any seq-to-seq task ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ EXAMPLES: ║ EXAMPLES: ║ EXAMPLES: ║
║ BERT, RoBERTa ║ GPT-4o, Claude 4, ║ T5, BART, ║
║ DeBERTa ║ Llama 4, Gemini 2.5 ║ mT5, FLAN-T5 ║
╚══════════════════╩═══════════════════════════╩═════════════════════════════════════╝
BERT czyta w obu kierunkach i nadaje się do zadań polegających na rozumieniu tekstu. GPT generuje treść od lewej do prawej przy użyciu maskowania przyczynowego. T5 zachowuje pełną architekturę do strukturalnej transformacji sekwencji. Wybór pomiędzy nimi dotyczy dopasowania architektury do zadania, a nie tego, który model jest lepszy. Krótko mówiąc, koder tworzy dwukierunkowe reprezentacje kontekstowe, dekoder generuje treść w sposób autoregresywny przy użyciu maskowania przyczynowego i mechanizmu cross-attention, a różne podzbiory tej architektury są dostosowywane do zadań rozumienia, generowania i transformacji.
Pozostałe elementy
Najwięcej uwagi poświęca się mechanizmowi attention oraz warstwie feed-forward, ale trzy inne elementy zapobiegają załamaniu się modeli typu deep transformer podczas treningu: same sieci feed-forward, normalizacja warstw oraz połączenia resztkowe.
Sieci feed-forward: czas przetwarzania na token
Po każdej warstwie uwagi w każdym bloku znajduje się sieć feed-forward przypisana do poszczególnych pozycji. Wektor każdego tokena przechodzi przez tę samą dwuwarstwową sieć MLP, zastosowaną oddzielnie do każdej pozycji: mnożony jest przez W1, dodawany jest bias, stosowana jest nieliniowość GeLU, a następnie mnożony ponownie przez W2 i dodawany kolejny bias. W1 mapuje wartości z d_model na cztery razy większą wartość, a W2 mapuje je z powrotem. W oryginalnych rozmiarach oznacza to 512, które zwiększa się do 2048, a następnie zmniejsza do 512, co daje sieci możliwość przechowywania i przetwarzania informacji, których sama warstwa uwagi nie jest w stanie uchwycić.
Kluczowym zwrotem jest „przypisana do poszczególnych pozycji”, ponieważ warstwa ta traktuje każdy token niezależnie. Warstwa uwagi stanowi mechanizm komunikacji, w którym tokeny rozmawiają ze sobą, natomiast sieć feed-forward jest mechanizmem obliczeniowym, w którym każdy token przetwarza informacje, które udało mu się zebrać.
Geva i współpracownicy (2021) odkryli, że warstwy te zachowują się nieco jak pamięci typu klucz-wartość, a można zidentyfikować poszczególne neurony, które aktywują się w związku z określonymi pojęciami semantycznymi. Gdy model językowy „wie”, że Paryż jest stolicą Francji, ta informacja znajduje się głównie w wagach przepływu przedniego. Tłumaczy to dwie rzeczy: doprecyzowanie modelu może aktualizować wiedzę faktograficzną, ponieważ modyfikuje te wagi. Generowanie wzbogacone o wydobycie informacji działa skutecznie, ponieważ umieszcza fakt w oknie kontekstowym, do którego uwaga może bezpośrednio dotrzeć.
Połączenia resztkowe
Gradienty przemieszczające się wstecz przez głęboką sieć kurczą się na przestrzeni wielu warstw. Połączenie resztkowe, nazywane również połączeniem pomijającym, sprawnie rozwiązuje ten problem: wyjście podwarstwy to wynik tej podwarstwy plus jej własny wejście. Warstwa musi wtedy nauczyć się jedynie zmiany, czyli reszty, a nie całego odwzorowania. Dzięki temu powstaje „autostrada”, po której gradienty mogą podróżować prosto wstecz, omijając każdą warstwę, i to dlatego nowoczesne transformery mogą mieć 96 lub więcej warstw bez spadku jakości treningu.
Normalizacja warstw: kontrola skali
Normalizacja warstwowa standaryzuje wektor aktywacji każdego tokena tak, aby miał zerową średnią i jednostkową wariancję, a następnie stosuje nauczony skalownik gamma oraz przesunięcie beta. Statystyki pochodzą z cech d_model jednego tokena: średnia to prosta średnia jego wartości, a wariancja to średnia kwadratowa odległości od tej średniej. Mała stała epsilon, zwykle 10 do ujemnej piątej, jest umieszczana wewnątrz pierwiastka kwadratowego, aby uniknąć dzielenia przez zero. W odróżnieniu od normalizacji partii, obliczenia są przeprowadzane dla każdego tokena osobno, a nie dla całej partii, co sprawdza się w sekwencjach o zmiennych długościach.
Współczesny wzorzec bloków
Oryginalny artykuł stosował LayerNorm po dodaniu reszty, co nazywane jest Post-LN. Prawie każdy nowoczesny model, od GPT-2 i GPT-3 po Llama oraz praktycznie wszystko, co zostało wytrenowane od około 2020 roku, wykorzystuje Pre-LayerNorm i normalizuje dane przed każdą podwarstwą. Pre-LN umożliwia stabilniejsze trenowanie i nie wymaga wcześniejszego dostosowywania szybkości uczenia się.
Każdy blok dodaje następnie gałąź uwagi oraz gałąź feed-forward do znormalizowanych danych wejściowych. Pierwszym stanem pośrednim jest dane wejściowe plus uwaga zastosowana do znormalizowanych danych, a drugim jest ten stan plus sieć feed-forward zastosowana do jej własnej wersji znormalizowanej. Przegląd kodu dowolnego nowoczesnego transformera pokazuje, że LayerNorm znajduje się przed mechanizmem uwagi oraz przed krokiem feed-forward. Powtarzając taki blok N razy, przy czym wartość N wynosi 6, 12, 24, 96 lub więcej w zależności od rozmiaru modelu, powstaje cały transformer.
Mechanizm uwagi to genialny pomysł. Te elementy wspomagające stanowią aspekty inżynieryjne, które umożliwiają realizację tego genialnego pomysłu. Warstwy feed-forward przeprowadzają obliczenia dla każdego tokena, przechowując informacje o powiązaniach faktograficznych; ścieżki reszydualne zapewniają gradientom drogę przez warstwy o różnej głębokości, a Pre-LN utrzymuje aktywacje w stabilnym stanie. Razem sprawiają one, że możliwe jest użycie dziesiątek takich bloków.
Droga zdania
Jedna pełna procedura polega na: tokenizacji, wpleceniu danych, dodaniu kodowania pozycji, kodowaniu, dekodowaniu jednego tokena po drugim, a następnie projekcji wyników do słownika. Następny diagram pokazuje proces tłumaczenia zdania „Hello world”:
╔══════════════════════════════════════════════════════════════════════════╗
║ END-TO-END DATA FLOW: "Hello world" → Translation ║
╚══════════════════════════════════════════════════════════════════════════╝
STAGE 1: Tokenization
┌─────────────────────────────────────────────────────────────────┐
│ Raw text: "Hello world" │
│ ↓ Tokenizer (BPE / WordPiece) │
│ Token IDs: [ 7592, 2088 ] ← integers into vocabulary │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 2: Embedding Lookup e_t = E[t] ∈ ℝ^512
┌─────────────────────────────────────────────────────────────────┐
│ 7592 → [0.21, -0.54, 0.88, ...] "Hello" │
│ 2088 → [0.67, 0.12,-0.34, ...] "world" │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 3: Add Positional Encoding x_t = e_t + PE(t)
┌─────────────────────────────────────────────────────────────────┐
│ embedding + PE = input vector carrying BOTH meaning AND order │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 4: Encoder Stack (× N layers)
┌─────────────────────────────────────────────────────────────────┐
│ ╔═══════════════════════════════════╗ │
│ ║ Each Encoder Layer: ║ × 6 │
│ ║ h₁ = x + Attn(LayerNorm(x)) ║ │
│ ║ h₂ = h₁ + FFN(LayerNorm(h₁)) ║ │
│ ╚═══════════════════════════════════╝ │
│ After 6 layers: rich contextual reps - "Hello" knows context │
└──────────────────────┬──────────────────────────────────────────┘
↓ (K, V flow into decoder cross-attention)
STAGE 5: Decoder Stack (generates tokens autoregressively)
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: <BOS> → Decoder → predict "Hola" │
│ Step 2: <BOS> "Hola" → Decoder → predict "mundo" │
│ Step 3: <BOS> "Hola mundo" → Decoder → predict <EOS> │
│ │
│ Each step: ① Masked self-attention on generated tokens │
│ ② Cross-attention: Q←decoder, K,V←encoder │
│ ③ LayerNorm → FFN → residual │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 6: Output Projection & Softmax
┌─────────────────────────────────────────────────────────────────┐
│ hidden state → W_vocab → logits over 50k vocab items │
│ → softmax → probability distribution │
│ → sample or argmax → next token │
└──────────────────────┬──────────────────────────────────────────┘
↓
"Hola mundo" ✓
Jak artykuł o tłumaczeniu stał się modelem językowym
To opisuje całą architekturę, ale jak projekt masowego tłumaczenia przekształcił się w systemy, które piszą eseje i kod oraz rozwiązują trudne problemy? Krótka odpowiedź brzmi: skalowanie.
Poniższa chronologia obejmuje transformery z 2017 roku aż po najnowsze zaawansowane modele:
YEAR MODEL PARAMS KEY DEVELOPMENT
────────────────────────────────────────────────────────────────────────────────
2017 Transformer 65M "Attention Is All You Need" published
2018 GPT-1 117M First successful generative pre-training
2019 GPT-2 1.5B Improved fluency; staged release
2020 GPT-3 175B Few-shot in-context learning emerges
2022 ChatGPT 175B+ InstructGPT + RLHF = aligned conversational AI
2023 GPT-4 undisclosed Multimodal input + stronger reasoning
2024 GPT-4o undisclosed Natively multimodal, faster & cheaper (May)
2024 o1 undisclosed "Reasoning" model: thinks before answering (Sep)
2025 o3 / o4-mini undisclosed Stronger reasoning, tool use, long-horizon
2025 Claude 4 undisclosed Anthropic: Opus 4 / Sonnet 4 (May)
2025 Gemini 2.5 undisclosed Google: 1M-token context, multimodal
2025 Llama 4 undisclosed Meta: open weights, up to 10M-token context
2026 GPT-5 series undisclosed OpenAI flagship (GPT-5.4 / 5.5); 272K-1M ctx
2026 Gemini 3.x undisclosed Google: frontier reasoning; 1M context
2026 Claude 5 family undisclosed Anthropic: Opus 4.8, Sonnet 5, Fable 5
2026 Grok 4.x undisclosed xAI frontier line (Grok 4.5, Jul 2026)
(Every one is the same core transformer from 2017 — scaled and refined, not replaced)
Podstawowa architektura prawie nie uległa zmianie pomiędzy GPT-1 a dzisiejszymi najnowocześniejszymi modelami. Zmieniły się następujące elementy:
- Masa obliczeniowa, czyli większa liczba parametrów, więcej danych oraz większe zasoby obliczeniowe.
- Dostosowanie, dzięki uczeniu się wzmacniającemu na podstawie informacji od ludzi, co sprawia, że modele są przydatne i bezpieczne.
- Dostrojenie do instrukcji, które uczy modele postępowania zgodnie z wytycznymi, a nie tylko kontynuowania tekstu.
- Trening umiejętności rozumowania, który wykorzystuje uczenie się wzmacniające na dużą skalę do rozwiązywania problemów poddawalnych weryfikacji. To właśnie on stanowi podstawę modeli rozumujących, takich jak seria o od OpenAI oraz tryby rozszerzonego myślenia powszechnie używane obecnie w Claude, Gemini i innych, które przed udzieleniem odpowiedzi poświęcają dodatkowy czas na przemyślenia.
Zdolności, które zdają się się aktywować
W miarę rozwoju modeli zdarzały się nieoczekiwane rzeczy. Pewne umiejętności nie poprawiały się stopniowo, lecz wydawało się, że rozwijają się gwałtownie przy określonych rozmiarach. Arytmetyka wieloetapowa była praktycznie nieobecna przy mniej niż około 10 miliardów parametrów, natomiast stawała się niezawodna przy około 100 miliardach. Rozumowanie łańcuchowe było w zasadzie nieobecne, chyba że model był wystarczająco duży i został o to poproszony. Generowanie kodu znacznie się poprawiło po osiągnięciu skali GPT-3. Nic z tego nie zostało zaprogramowane – po prostu się pojawiło.
Sporna jest kwestia tego, na ile realne są te gwałtowne skoki. Powszechnie cytowana analiza z 2023 roku autorstwa Schaeffera i współpracowników zatytułowana „Czy emergentne zdolności dużych modeli językowych to miraż?” pokazała, że niektóre pozorne nagłe zmiany wynikają częściowo z użytej metryki. Ocena zadania jako „wszystko albo nic”, jak to robi dokładność dopasowania, może przekształcić stopniowy postęp w coś, co wygląda jak nagły skok, podczas gdy metryka ciągła ukazuje rzeczywisty, powolny rozwój. Prawda ta pozostaje aktualna – duże modele potrafią robić rzeczy, których nie mogą małe – ale konkretne wartości progowe należy traktować jedynie jako przybliżone ilustracje, a nie jako niepodważalne fakty fizyczne.
Celem treningu każdego modelu w stylu GPT jest ta sama prosta zadanie – przewidywanie następnego tokena. Rozumowanie, generowanie kodu, zrozumienie w językach obcych oraz pisanie kreatywne nigdy nie są trenowane w sposób wyraźny. Pojawiają się one w miarę jak model staje się lepszy w przewidywaniu następnego tokena, pod warunkiem dostatecznej skali: dużego, wysokiej jakości i zróżnicowanego korpusu oraz modelu na tyle dużego, by móc przechowywać niezbędne wzorce. Dlatego badacze określają ten cel jako zwodniczo prosty. Cel rzeczywiście jest prosty, ale to, czego model musi się nauczyć, aby dobrze w nim radzić sobie, nie jest prostym zadaniem.
Okno kontekstowe jako pamięć robocza
Pamięć robocza modelu to okno kontekstowe – maksymalna liczba tokenów, które może on przetworzyć podczas jednej rundy obliczeń. Jej rozwoj był dramatyczny: GPT-2 w 2019 roku radził sobie z 1 024 tokenami, a GPT-3 w 2020 roku z 2 048. GPT-4o w 2024 roku osiągnął już 128 000 tokenów. Do połowy 2026 roku ten próg znacznie wzrósł – seria GPT-5 od OpenAI oferuje standardowo 272 000 tokenów, a poprzez API nawet około miliona; Claude od Anthropic oraz Gemini 3 od Google również dostarczają ponad milion tokenów, natomiast otwarty model Llama 4 Scout od Meta obiecuje aż 10 milionów tokenów, co odpowiada około 15 000 stronom. Te wartości stale rosną z każdą nową generacją.
Większe okno kontekstowe jest ważne, ponieważ umożliwia analizę całego pliku kodu, a nie tylko jego fragmentów, utrzymanie spójności rozmowy przez wiele kroków, streszczanie całych dokumentów oraz przeprowadzanie wieloetapowych rozumowań z uwzględnieniem wielu pośrednich wyników.
Istnieje jednak haczyk. Obliczanie pełnej macierzy uwagi, która łączy każdy token z każdym innym, wymaga podczas treningu czasu i pamięci proporcjonalnych do O(n kwadrat), a podwojenie długości kontekstu powoduje czterokrotny wzrost obu tych zasobów. Podczas inferencji buforowanie danych typu KV zmniejsza obciążenie obliczeniowe na krok, ale pamięć nadal rośnie liniowo wraz z długością kontekstu. Ten kwadratowy problem podczas treningu jest przedmiotem intensywnych badań. Rzadka uwaga, uwaga z przesuwanym oknem stosowana w modelach typu Mistral oraz inne efektywne rozwiązania, Flash Attention (dokładna uwaga o niskim zużyciu pamięci) oraz aproksymacje liniowe – wszystko to ma na celu zmniejszenie kosztów obliczeniowych.
Czym jest podstawa?
Uwaga, mechanizm QKV, kilka głow obliczeniowych, kodowanie pozycyjne oraz struktura encoder-decoder stanowią infrastrukturę, a powodem ich nauki jest to, co zostaje zbudowane na ich bazie.
Sztuczna inteligencja generatywna to powtarzane przewidywanie następnego tokena
Każda aplikacja generatywna to w gruncie rzeczy ten sam pętla wykonywany raz po raz:
Prompt: "Write a poem about autumn"
↓
Model predicts most likely next token: "The"
↓
Prompt + "The" → predicts: "leaves"
↓
Prompt + "The leaves" → predicts: "fall"
↓
... continues until <end-of-sequence> token predicted
Takie spojrzenie na sprawę usuwa tajemnicę z kilku zachowań:
- Hallucynacje. Model przewiduje prawdopodobne tokeny i nie pobiera faktów z bazy danych. Jeśli dostępny jest wiarygodny, lecz błędny token, może zostać on wygenerowany.
- Dlaczego kontekst ma tak wielkie znaczenie. W każdym kroku generowania bierze się pod uwagę całe okno kontekstowe, więc to, co znajduje się w promptzie, wpływa na obliczane wagi uwagi, a tym samym na wynik.
Uczenie się w kontekście: uwaga służąca do wyszukiwania
Jedną z najbardziej imponujących umiejętności dużych transformatorów jest uczenie się w kontekście – zdolność dostosowywania się do nowego zadania na podstawie przykładów zawartych w instrukcji bez żadnej dodatkowej kalibracji. Mechanizm ten odpowiada temu, co omówiono powyżej. Przykłady typu few-shot zajmują określone pozycje w oknie danych. Gdy model przetwarza instancję testową, zapytanie tego tokena jest porównywane za pomocą iloczynu skalarnego z kluczami wszystkich wcześniejszych tokenów, włączając pary przykładów. Ponieważ przykłady te mają wspólny wzorzec strukturalny z instancją testową, ich klucze dobrze się pokrywają, a ich wartości otrzymują wysokie wagi. Uwaga jest dosłownie mechanizmem wyszukiwania, i właśnie dlatego struktura instrukcji, poprzez wpływ na wzorce uwagi, zmienia wynik wyjściowy.
Agenci: transformator jako silnik rozumowania
Agenci AI to systemy, które same dzielą zadania na części, wykorzystują narzędzia, korygują działania na podstawie informacji zwrotnych i dążą do celów w wielu krokach. W 2023 roku były one jedynie przedmiotem badań naukowych. Obecnie produkty takie jak Claude Code, GitHub Copilot, Cursor i Devin są codziennie używane przez programistów. Każdy poważny agent ma w swojej strukturze element typu transformer.
╔══════════════════════════════════════════════════════════════════════════════╗
║ THE CONTEXT WINDOW AS AGENT WORKING MEMORY ║
╚══════════════════════════════════════════════════════════════════════════════╝
TIME ──────────────────────────────────────────────────────────────────────▶
┌──────────────┬──────────────┬────────────────┬────────────┬──────────────┐
│ SYSTEM │ USER │ AGENT │ TOOL │ AGENT │
│ PROMPT │ MESSAGE │ THOUGHT │ RESULT │ RESPONSE │
│ │ │ (reasoning) │ │ │
│ "You are a │ "What is │ <think> │ {"temp": │ "The current │
│ weather │ the weather │ I need to │ 22, │ temperature │
│ assistant │ in Paris │ call the │ "unit": │ in Paris │
│ ..." │ today?" │ weather API │ "C", │ is 22°C and │
│ │ │ for Paris... │ "cond": │ cloudy." │
│ │ │ </think> │ "cloudy"} │ │
│ ~200 tokens │ ~15 tokens │ ~80 tokens │ ~40 tokens │ ~25 tokens │
└──────────────┴──────────────┴────────────────┴────────────┴──────────────┘
▲ ▲ ▲ ▲ ▲
└───────────────┴───────────────┴───────────────┴─────────────┘
│
At each generation step:
Full self-attention runs over the
ENTIRE context simultaneously.
Cost: O(n²) in total context length.
WHAT THIS MEANS FOR AGENTS:
✓ Tool results are just tokens - the model attends to them like any text
✓ Reasoning traces are visible - chain-of-thought shapes next generation
✓ Long task history - "memory" without any separate mechanism
⚠ Context fills up - very long loops need summarization/offload
⚠ O(n²) attention cost - longer context = quadratically more compute
KEY INSIGHT: There is no "working memory" separate from the context.
The context window IS the agent's entire cognitive state.
Dla agenta okno to jedna płaska, uporządkowana buforowa struktura tokenów, a każdy krok generowania obejmuje całą tę strukturę, dzięki czemu wszystko, co się wydarzyło, pozostaje w zasięgu aż do określonego limitu. Okno stanowi pamięć roboczą agenta, uwaga jest jego mechanizmem rozumowania, a pętla następnego tokena to jego pętla działań. Sztuczna inteligencja agentowa nie wymagała nowej architektury – wystarczyło zauważyć, że model typu transformer w wystarczająco dużej skali może już wspierać funkcjonowanie agenta.
W praktyce agenci stworzone w 2026 roku rzadko polegają wyłącznie na samej oknie. Aby sprostać długim zadaniom, dodają pamięć zewnętrzną: pliki tymczasowe, warstwę wyszukiwania lub bazę wiedzy, którą stale aktualizują. Nie stoi to w sprzeczności z powyższym stwierdzeniem, ponieważ pamięć zewnętrzna wpływa na model jedynie poprzez odczytanie jej z powrotem do okna. Rozszerza ona bufor, nie zastępując go, a uwaga transformera wobec tego kontekstu pozostaje jedynym miejscem, gdzie odbywa się proces myślenia.
Kierunek badań
Wydajność transformerów podąża za przewidywalnymi prawami potęgowymi w zakresie parametrów, danych treningowych i zasobów obliczeniowych, co daje badaczom wyraźny plan działania. Przyszłość rozwoju kieruje się kilkoma ścieżkami:
- Efektywne architektury, które zmniejszają kwadratową kosztowność mechanizmu uwagi, dzięki technikom takim jak Flash Attention, sparse attention i linear attention.
Wszystko to opiera się na fundamentach transformera, więc znajomość tych zasad ułatwia zrozumienie tych kierunków rozwoju.
Poniższa tabela przedstawia każdy składnik w jednym widoku, wskazując problem, który rozwiązuje, sposób jego działania oraz główne właściwości:
| Component | Problem it Solves | Core Mechanism | Key Properties |
|-----------|------------------|----------------|----------------|
| **Tokenization** | Text is not natively numeric | Subword BPE/WordPiece splitting | Vocabulary ≈ 30k–100k; subwords handle rare terms |
| **Embeddings** | Discrete IDs have no geometry | $\mathbf{e}_t = E[t] \in \mathbb{R}^{d_{\text{model}}}$ | Semantic similarity → geometric proximity |
| **Positional Encoding** | Parallel attention loses token order | sin/cos at different frequencies (or RoPE) | Multi-scale; encodes absolute and relative position |
| **Self-Attention** | Long-range deps, sequential bottleneck | $\text{softmax}(QK^\top/\sqrt{d_k})V$ | $O(n^2)$ but parallel; dynamic contextual reps |
| **Query/Key/Value** | Separating "what I seek" from "what I offer" | Three separate learned linear projections | Relevance ≠ similarity; flexible dependency modeling |
| **Multi-Head Attention** | Single head captures only one relationship type | $h$ parallel heads, concatenated + $W^O$ | Simultaneously captures syntactic, semantic, positional |
| **Encoder** | Understanding input in full bidirectional context | Full self-attention, no masking | Bidirectional; rich contextualized representations |
| **Decoder** | Generating output autoregressively | Causal self-attention + cross-attention | Predicts one token at a time; teacher-forcing in training |
| **Cross-Attention** | Connecting generation to input understanding | Q from decoder, K/V from encoder | Enables encoder→decoder communication |
| **Feed-Forward Network** | Per-token computation + factual storage | $\text{GeLU}(\mathbf{x}W_1)\,W_2$ per token | Position-wise; stores factual associations in weights |
| **Residual Connections** | Vanishing gradients in deep networks | $\mathbf{h} = \text{SubLayer}(\mathbf{x}) + \mathbf{x}$ | Creates gradient highway; enables 100+ layer models |
| **Pre-LayerNorm** | Unstable activations in deep networks | Normalize before each sublayer | Stable training; standard in all modern transformers |
Co zostało omówione i dokąd iść dalej
Części łączą się ze sobą w następujący sposób. Równoległe przetwarzanie uwagi działa lepiej niż krok po kroku i skuteczniej wykrywa odległe zależności, dlatego transformery wyparły modele sekwencyjne. Dane przepływają od tekstu do tokenów, potem do embeddingów, dalej do kodowania pozycyjnego, następnie do mechanizmu uwagi i warstw feed-forward, a proces się powtarza. Podstawową operacją jest samouwaga – każdy token reaguje na wszystkie pozostałe za pomocą nauczonych projekcji Q, K i V, zgodnie ze wzorem Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Wielokrotne głowy przetwarzające wykrywają różnorodne wzorce, kodowanie pozycyjne przywraca porządek, a architektura encoder-decoder umożliwia zarówno rozumienie, jak i generowanie treści. Warstwy feed-forward przechowują wiedzę, łącza resztkowe zapewniają głębię przetwarzania, a Pre-LayerNorm utrzymuje stabilność treningu. Przewidywanie następnego tokena na dużą skalę daje efekt emergentny, okno kontekstowe pełni rolę pamięci roboczej agenta, a architektura to fr
Artykuły z 2017 roku napędzają najnowocześniejsze systemy dzisiaj.
Aby zagłębić się w temat, dobrze sprawdzi się stopniowy plan.
Pierwsze dwa tygodnie: matematyka. Przejrzyj serię filmów Andreja Karpathy’ego „Neural Networks: Zero to Hero” na YouTube, szczególnie ten, w którym buduje się GPT od zera. Następnie napisz prostą warstwę samouwagi w NumPy. Po obliczeniach ręcznych koncepcje te są lepiej zrozumiałe.
Tygodnie trzeci i czwarty: artykuły naukowe. Przeczytaj „Attention Is All You Need” (Vaswani i wsp., 2017), który jest już dostępny do przeczytania, a także artykuł o BERT (Devlin i wsp., 2018), artykuł o GPT-3 „Language Models are Few-Shot Learners” (Brown i wsp., 2020) oraz „Scaling Laws for Neural Language Models” (Kaplan i wsp., 2020).
Drugi miesiąc: ćwiczenia z bibliotekami i API. Biblioteka Hugging Face transformers umożliwia korzystanie z tych modeli w Pythonie przy minimalnym konfigurowaniu. Dostosuj BERT lub mały model o otwartych wagach, takich jak warianty Llama czy Qwen, do zadań klasyfikacyjnych. Następnie skorzystaj z interfejsu Python SDK od Anthropic lub OpenAI, aby dotrzeć do najnowszych modeli, takich jak Claude Sonnet 5 lub modele GPT-5. Połączenie obu podejść łączy teorię z praktyką, ponieważ te same zasady transformatorów są widoczne zarówno w modelach o otwartych wagach, jak i w najnowszych modelach API.
Trzeci miesiąc: pogłębione zajmowanie się jedną dziedziną. Wybierz jeden z frameworki do tworzenia agentów (LangChain, LlamaIndex) lub poświęć czas na korzystanie z Claude Code lub Cursor, aby obserwować zachowanie agentów w rzeczywistym narzędziu produkcyjnym, skup się na efektywnych transformatorach (Flash Attention, rzadka i liniowa uwaga) lub na dostosowywaniu modeli LLM za pomocą LoRA i PEFT. Tutaj ważniejsza jest głębia niż szerokość.
Ciągłe aktualizacje: bądź na bieżąco z badaniami. Sekcje cs.CL i cs.LG na arXiv, blog Hugging Face, strona badawcza Anthropic oraz Forum AI Alignment to dobre źródła informacji. Dziedzina rozwija się szybko, ale powyższe podstawy sprawiają, że nowe prace są zrozumiałe.
Artykuł o transformatorach ma około piętnastu stron, a opisana w nim architektura jest na tyle prosta, że można ją zaimplementować w ciągu popołudnia. To, co zostało tym uruchomione, a także to, co wciąż pojawia się dzięki dalszemu skalowaniu i udoskonaleniom, zmieniło postrzeganie tego, co maszyny potrafią robić.