Tip
\nChcesz uruchomić ten kod samemu? Wszystkie przykłady z tego posta (perceptron, RNN, LSTM) znajdziesz w gotowym notatniku Jupyter: od-prostych-neuronow-do-pamieci.ipynb
\nW poprzednim wpisie przeszliśmy całą drogę od cięcia tekstu na tokeny, przez liczenie słów (TF-IDF), łańcuchy Markowa, aż po Word2Vec i wektory znaczeń. I na koniec pojawiło się jedno fundamentalne pytanie...
\nMamy wektory słów. Super. Ale jak z nich zbudować coś, co rozumie zdanie? Albo cały paragraf? Albo książkę?
\nBo przecież "Dog bites man" to nie jest po prostu "dog" + "bites" + "man". To jest sekwencja - słowa następują po sobie w określonym porządku i ten porządek zmienia znaczenie. "Dog bites man" i "Man bites dog" to te same słowa, ale zupełnie inne historie :D
\nA Word2Vec? Word2Vec patrzy na słowa pojedynczo. Nie ma pojęcia kolejności. Nie wie, że "nie" przed "lubie" zmienia wszystko.
\nWięc potrzebujemy czegoś, co potrafi przetwarzać sekwencje. Coś, co czyta tekst w kolejności i buduje zrozumienie krok po kroku.
\nI tu zaczyna się fascynująca historia - bo rozwiązanie tego problemu nie pojawiło się z dnia na dzień. To była ewolucja, która trwała kilkadziesiąt lat. Od jednego, prostego neuronu, do skomplikowanych komórek pamięci. I każda generacja rozwiązywała problem poprzedniej, ale tworzyła nowy.
\nTo jest czwarty wpis z serii "zrozumiec LLM". Dzisiaj idziemy głębiej w architekturę sieci neuronowych - ale spokojnie, dalej bez wzorów, których nie da się zrozumieć ;-) Zamiast tego będzie dużo metafor, diagramów i przykładów z życia.
\ntimeline\n title Ewolucja architektur neuronowych\n 1943 : McCulloch & Pitts<br/>model matematyczny neuronu\n 1958 : Rosenblatt<br/>perceptron\n 1986 : Rumelhart et al.<br/>backpropagation + MLP\n 1986 : RNN<br/>sieci rekurencyjne\n 1997 : Hochreiter & Schmidhuber<br/>LSTM\n 2017 : Vaswani et al.<br/>Transformer (cliffhanger!)\nNarracja dzisiejszego wpisu: "Od jednej komórki do pamięci - i dlaczego to wciąż nie wystarczyło." Zaczynamy od podstaw.
\nZanim wejdziemy w architektury, szybko załatwmy jedno pytanie, które pewnie sobie zadajecie: dlaczego w ogóle nazywa się to "siecią neuronową"? Co to ma wspólnego z mózgiem?
\nOdpowiedź: i dużo, i mało ;-) Na początku była inspiracja biologią. Spójrzcie:
\ngraph LR\n BD["🌿 Dendryty<br/><i>odbierają sygnały</i>"] --> BS["🧫 Soma<br/><i>przetwarza</i>"]\n BS --> BA["⚡ Akson<br/><i>przekazuje dalej</i>"]\ngraph LR\n SD["📥 Wejścia x₁, x₂, x₃<br/><i>liczby</i>"] --> SS["➕ Suma ważona<br/><i>w₁x₁ + w₂x₂ + w₃x₃ + b</i>"]\n SS --> SA["📤 Wyjście<br/><i>aktywacja(suma)</i>"]\nPierwszy diagram - prawdziwy neuron. Ma dendryty (odbierają sygnały od innych neuronów), somę (ciało komórki - decyduje czy "odpalić"), i akson (przekazuje sygnał dalej).
\nDrugi diagram - sztuczny neuron. Ma wejścia (liczby), sumę ważoną (mnoży każde wejście przez jego "ważność" i dodaje wszystko), i wyjście (wynik przepuszczony przez funkcję aktywacji).
\nPodobieństwo jest... luźne. Biologiczny neuron jest niewyobrażalnie bardziej skomplikowany. Ale inspiracja była ważna - Warren McCulloch i Walter Pitts w 1943 roku pokazali, że taki uproszczony model neuronu potrafi realizować podstawowe operacje logiczne (AND, OR, NOT). A to oznaczało, że sieć takich neuronów mogłaby teoretycznie obliczać cokolwiek.
\nNote
\nCzy LLM "myśli" jak mózg? Nie. Neuron sztuczny to matematyczna abstrakcja, nie model biologiczny. Biologiczny neuron używa impulsów elektrycznych, neuroprzekaźników, ma tysiące połączeń i dynamikę, której nie da się sprowadzić do w₁x₁ + w₂x₂. Ale inspiracja była punktem wyjścia - i to ważny punkt.
OK, to tyle biologii. Przejdźmy do tego, co z tego wynikło ;-)
\nW 1958 roku Frank Rosenblatt stworzył perceptron - pierwszy algorytm, który potrafił się uczyć na podstawie danych. To był kamień milowy.
\nPerceptron działa banalnie prosto. Wyobraźcie sobie, że decydujecie, czy wyjść na spacer:
\ngraph TD\n S["☀️ Słonecznie?"] -->|"w = +5"| SUM["➕ SUMA"]\n D["🌧️ Pada deszcz?"] -->|"w = -8"| SUM\n T["🌡️ Temperatura > 20°C?"] -->|"w = +3"| SUM\n BIAS["⚙️ Próg (bias) = 0"] --> SUM\n SUM --> DEC{"Suma >= próg?<br/>(próg = 0)"}\n DEC -->|"Tak"| Y["✅ Wychodzę na spacer!"]\n DEC -->|"Nie"| N["❌ Zostaję w domu"]\n \n style S fill:#ffcc99,color:#000\n style D fill:#9999ff,color:#fff\n style T fill:#ff9999,color:#000\n style SUM fill:#99ff99,color:#000\n style Y fill:#66cc66,color:#fff\n style N fill:#cc6666,color:#fff\nMechanika jest prosta:
\nPrzykład:
\n| Sytuacja | \nSłońce (+5) | \nDeszcz (-8) | \nTemp >20° (+3) | \nSuma | \nDecyzja | \n
|---|---|---|---|---|---|
| Słonecznie, ciepło, bez deszczu | \n1 | \n0 | \n1 | \n5 + 0 + 3 = 8 | \n✅ Wychodzę | \n
| Pada, zimno | \n0 | \n1 | \n0 | \n0 - 8 + 0 = -8 | \n❌ Zostaję | \n
| Pochmurno i pada, ale ciepło | \n0 | \n1 | \n1 | \n0 - 8 + 3 = -5 | \n❌ Zostaję | \n
I - najważniejsze - perceptron potrafi uczyć się tych wag. Pokazujecie mu 100 przykładów "wyszedłem / nie wyszedłem" i on stopniowo dostosowuje wagi, żeby jego decyzje pasowały do waszych.
\nGenialne w swojej prostocie, prawda?
\nPerceptron potrafi narysować jedną prostą linię dzielącą dane na dwie grupy. Co jest super, jeśli dane da się tak podzielić:
\n⚫ ⚫ ⚫ │ ⚪ ⚪ ⚪\n⚫ ⚫ ⚫ │ ⚪ ⚪ ⚪\n ↑\n jedna linia dzieli je ✅\nAle co jeśli dane wyglądają tak?
\n⚪ ⚫\n\n⚫ ⚪\nTo jest słynny problem XOR (exclusive OR). Wyjście jest "prawdziwe" tylko wtedy, gdy dokładnie jedno wejście jest prawdziwe - nie oba i nie żadne. I nie da się narysować jednej prostej linii, która by to oddzieliła.
\nTen problem zatrzymał rozwój sieci neuronowych na prawie 20 lat. Serio. Badacze powiedzieli: "no dobra, perceptron jest fajny, ale skoro nie radzi sobie z czymś tak prostym jak XOR, to po co to w ogóle?" Ten okres nazywa się "AI Winter" (zima AI).
\nWarning
\nDlaczego XOR był taki ważny? Bo pokazał, że pojedynczy perceptron jest ograniczony do problemów liniowo separowalnych. A prawdziwy świat rzadko jest liniowy. Język na pewno nie jest.
\nI wtedy ktoś powiedział: a co jeśli połączymy kilka perceptronów razem?
\nMultilayer Perceptron (MLP) to sieć złożona z wielu warstw neuronów. Zamiast jednej warstwy decyzyjnej, mamy:
\ngraph LR\n subgraph "Warstwa wejściowa"\n X1["x₁"]\n X2["x₂"]\n X3["x₃"]\n end\n subgraph "Warstwa ukryta 1"\n H1["h₁<br/><i>proste cechy</i>"]\n H2["h₂"]\n H3["h₃"]\n H4["h₄"]\n end\n subgraph "Warstwa ukryta 2"\n G1["g₁<br/><i>kombinacje</i>"]\n G2["g₂"]\n G3["g₃"]\n end\n subgraph "Warstwa wyjściowa"\n Y1["y₁<br/><i>decyzja</i>"]\n Y2["y₂"]\n end\n \n X1 --> H1 & H2 & H3 & H4\n X2 --> H1 & H2 & H3 & H4\n X3 --> H1 & H2 & H3 & H4\n H1 --> G1 & G2 & G3\n H2 --> G1 & G2 & G3\n H3 --> G1 & G2 & G3\n H4 --> G1 & G2 & G3\n G1 --> Y1 & Y2\n G2 --> Y1 & Y2\n G3 --> Y1 & Y2\n \n style X1 fill:#ff9999,color:#000\n style X2 fill:#ff9999,color:#000\n style X3 fill:#ff9999,color:#000\n style H1 fill:#ffcc99,color:#000\n style H2 fill:#ffcc99,color:#000\n style H3 fill:#ffcc99,color:#000\n style H4 fill:#ffcc99,color:#000\n style G1 fill:#99ff99,color:#000\n style G2 fill:#99ff99,color:#000\n style G3 fill:#99ff99,color:#000\n style Y1 fill:#9999ff,color:#fff\n style Y2 fill:#9999ff,color:#fff\nKażdy neuron w jednej warstwie jest połączony z każdym neuronem w warstwie następnej (dlatego to się nazywa "fully connected" albo "dense").
\nMetafora, która mi najbardziej pasuje:
\nWyobraźcie sobie firmę. Analitycy (warstwa 1) patrzą na surowe dane i wyłapują proste wzorce. Menedżerowie (warstwa 2) łączą te wzorce w coś bardziej sensownego. Dyrektor (warstwa wyjściowa) podejmuje ostateczną decyzję. Żadna z tych osób nie rozumie pełnego obrazu sama - ale razem tworzą kaskadę abstrakcji.
\nI właśnie to rozwiązuje problem XOR! Pierwsza warstwa rysuje dwie linie. Druga warstwa łączy je w jeden obszar. Nagle nieliniowy problem staje się rozwiązywalny.
\nDodanie warstw ukrytych samo w sobie nic nie daje. Dlaczego?
\nBo jeśli każda warstwa robi tylko suma = wagi × wejścia + bias, to dwie warstwy takiej operacji to nadal... jedna wielka operacja liniowa. Pokażę na liczbach:
Warstwa 1: y = 2·x + 1\nWarstwa 2: z = 3·y + 2
Podstawiamy pierwsze do drugiego:
\nz = 3·(2·x + 1) + 2\nz = 6·x + 3 + 2\nz = 6·x + 5 ← jedna operacja, tylko z innymi liczbami\nDwie warstwy złożyły się w jedną. Zamiast dwóch transformacji, dostajecie jedną - tylko z innymi współczynnikami. To jakbyście zamiast dwóch filtrów do kawy użyli jednego, ale dwa razy grubszego. Efekt ten sam.
\nWięc potrzebujemy czegoś nieliniowego pomiędzy warstwami. I tu wkracza...
\nFunkcja aktywacji to taka "niestandardowa przetwórnia", którą przepuszczamy wynik sumy. Najpopularniejsza dziś to ReLU (Rectified Linear Unit):
\ndef relu (x ):\n if x > 0 :\n return x \n else :\n return 0 To wszystko. Jeśli wartość jest dodatnia - zostaw. Jeśli ujemna - wyzeruj.
\nBrzmi banalnie? Jest banalnie. Ale ta jedna prosta operacja łamie liniowość.
\nWracamy do naszego przykładu z liczbami. Bez ReLU dwie warstwy złożyły się w jedną (z = 6·x + 5). Ale teraz wstawmy ReLU między nimi:
Warstwa 1: y = ReLU(2·x + 1)\nWarstwa 2: z = ReLU(3·y + 2)\nSprawdźmy dla trzech wartości x:
| x | \n2·x + 1 | \ny (po ReLU) | \n3·y + 2 | \npo ReLU | \nBez ReLU (6·x + 5) | \n
|---|---|---|---|---|---|
| -2 | \n-3 | \n0 ⬅ wyzerowane! | \n2 | \n2 | \n-7 | \n
| 0 | \n1 | \n1 | \n5 | \n5 | \n5 | \n
| 1 | \n3 | \n3 | \n11 | \n11 | \n11 | \n
Bez ReLU wynik zmienia się liniowo (-7, 5, 11 - stały przyrost). Z ReLU nagle dla x = -2 dostajemy 2 zamiast -7. Ta relacja nie jest już prostą linią. Wyzerowanie ujemnych wartości jest czymś, czego nie da się wyrazić jako a·x + b - i właśnie dlatego warstwy przestają się sklejać w jedną.
Analogia: wyobraź sobie żaluzje w oknie. Liniowość to przezroczysta szyba - przepuszcza wszystko, lekko przyciemnione. ReLU to żaluzje, które całkowicie blokują światło poniżej pewnego kąta. Nie da się symulować "całkowitego zablokowania" przez "mocniejsze przyciemnienie szyby". To jakościowo inna operacja.
\nDzięki ReLU każda warstwa robi coś innego niż poprzednia. I nagle sieć z wielu warstw staje się potężna - potrafi modelować nieliniowe, skomplikowane relacje w danych.
\nImportant
\nReLU w pigułce: Bez funkcji aktywacji (nieliniowej) między warstwami, sieć z 100 warstwami jest równie ekspresywna jak sieć z 1 warstwą. ReLU (i jego kuzyni: sigmoid, tanh, GELU) to składnik, który sprawia, że głębokość ma sens.
\nInne popularne funkcje aktywacji:
\n| Funkcja | \nWzór (w uproszczeniu) | \nZakres | \nGdzie używana | \n
|---|---|---|---|
| ReLU | \nmax(0, x) | \n[0, +∞) | \nWarstwy ukryte (standard) | \n
| Sigmoid | \n1 / (1 + e⁻ˣ) | \n(0, 1) | \nBramki LSTM, output binarny | \n
| Tanh | \n(eˣ - e⁻ˣ) / (eˣ + e⁻ˣ) | \n(-1, 1) | \nBramki LSTM, hidden states | \n
| Softmax | \neˣⁱ / Σeˣʲ | \n(0, 1), suma = 1 | \nWarstwa wyjściowa (klasyfikacja) | \n
Tip
\nEksperyment dla was: Otwórzcie Python i odpalcie to:
\nimport numpy as np \n\ndef relu (x ):\n return np .maximum (0 , x )\n\nx = np .array ([- 3 , - 1 , 0 , 2 , 5 ])\nprint (f"Wejście: { x } " )\nprint (f"Po ReLU: { relu ( x ) } " )Zobaczycie jak ReLU "odcina" wszystko, co jest poniżej zera. Ta prosta operacja pozwala sieci "wybierać", które cechy są aktywne, a które ignorować.
\nOK, mamy MLP. Potrafi modelować nieliniowe relacje. Super. Ale jest jeden fundamentalny problem, który blokuje nas przed używaniem MLP do języka.
\nMLP widzi wszystkie cechy naraz. Nie ma pojęcia kolejności.
\nWeźmy klasyczny angielski przykład. Dwa zdania z dokładnie tymi samymi słowami, ale w innej kolejności:
\n| Zdanie | \ndog | \nbites | \nman | \n
|---|---|---|---|
| "Dog bites man" | \n1 | \n1 | \n1 | \n
| "Man bites dog" | \n1 | \n1 | \n1 | \n
Identyczny wektor. A znaczenie? Pierwsze to nudna wiadomość. Drugie to sensacja w gazecie :D
\nDla MLP oba zdania to dokładnie to samo - bo MLP dostaje ten sam wektor i nie ma pojęcia kolejności.
\nNote
\nA co z polskim? Polski jest tu podchwytliwy - przez fleksję (7 przypadków!) rzadko mamy dwa zdania z dokładnie tymi samymi formami słów. "Pies gryzie człowieka" vs "Człowiek gryzie psa" to różne formy (pies→psa, człowieka→człowiek). Ale angielski, z minimalną odmianą, idealnie pokazuje ten problem. I właśnie dlatego przykłady z bag-of-words często używają angielskiego ;-)
\nTo jest problem permutacji - MLP nie odróżnia [A, B, C] od [C, B, A]. A w języku kolejność jest wszystkim. "Nie lubię" vs "Lubię nie" - same słowa, zupełnie inne znaczenie.
Można by pomyśleć: "OK, to dodajmy pozycję słowa jako cechę". Ale to nie rozwiązuje problemu - MLP nadal nie rozumie, że słowo na pozycji 1 ma związek ze słowem na pozycji 5. Każda pozycja to po prostu kolejna liczba na wejściu.
\nWięc potrzebujemy czegoś, co przetwarza dane krok po kroku, w kolejności, i buduje zrozumienie sekwencyjnie. Tak jak my czytamy książkę - zdanie po zdaniu, słowo po słowie.
\nI tu wkracza RNN.
\nRecurrent Neural Network (RNN) to sieć, która ma coś, czego MLP nie ma: pamięć. No... jako tako ;-)
\nWyobraźcie sobie, że czytacie książkę. Nie czytacie całej strony naraz (jak robiłby MLP). Czytacie słowo po słowie, zdanie po zdaniu. I przy każdym nowym słowie aktualizujecie swoje zrozumienie tego, co się dzieje.
\nDokładnie to robi RNN. Ma hidden state (ukryty stan) - to jest jego "rozumienie tekstu do tej pory". Przy każdym nowym słowie:
\ngraph LR\n subgraph "RNN czyta: 'Kot siedzi na macie'"\n X1["📖 'Kot'"] --> RNN1["🔄 RNN<br/>h₁"]\n RNN1 --> |"rozumie:<br/>'mowa o kocie'"| RNN2["🔄 RNN<br/>h₂"]\n X2["📖 'siedzi'"] --> RNN2\n RNN2 --> |"rozumie:<br/>'kot coś robi'"| RNN3["🔄 RNN<br/>h₃"]\n X3["📖 'na'"] --> RNN3\n RNN3 --> RNN4["🔄 RNN<br/>h₄"]\n X4["📖 'macie'"] --> RNN4\n RNN4 --> |"rozumie:<br/>'kot siedzi na macie'"| OUT["✅ Pełne zrozumienie"]\n end\n \n style X1 fill:#ffcc99,color:#000\n style X2 fill:#ffcc99,color:#000\n style X3 fill:#ffcc99,color:#000\n style X4 fill:#ffcc99,color:#000\n style RNN1 fill:#9999ff,color:#fff\n style RNN2 fill:#9999ff,color:#fff\n style RNN3 fill:#9999ff,color:#fff\n style RNN4 fill:#9999ff,color:#fff\n style OUT fill:#66cc66,color:#fff\nTen diagram to jest właśnie unrolling (rozwinięcie w czasie). W rzeczywistości to ten sam neuron RNN - ale "odwijamy" go w czasie, żeby pokazać, jak przetwarza kolejne słowa. Zauważcie: strzałka idzie od lewej do prawej - informacja płynie sekwencyjnie.
\nTo jest genialne w swojej prostocie. RNN "czyta" tekst tak jak my - po kolei, budując zrozumienie krok po kroku.
\nŻeby to naprawdę poczuć, napiszmy najprostszy możliwy RNN. Bez PyTorcha, bez TensorFlow - sam NumPy:
\nimport numpy as np \n\ndef simple_rnn (word_vectors , hidden_size = 4 ):\n words , dim = word_vectors .shape \n np .random .seed (42 )\n \n W_h = np .random .randn (hidden_size , hidden_size ) * 0.01 \n W_x = np .random .randn (hidden_size , dim ) * 0.01 \n bias = np .zeros (hidden_size )\n \n h = np .zeros (hidden_size )\n \n for t , word in enumerate (word_vectors ):\n h = np .tanh (W_h @ h + W_x @ word + bias )\n print (f" Krok { t + 1 } : hidden state = { np . round ( h , 2 ) } " )\n \n return h \n\nkot = np .array ([1.0 , 0.0 ])\nsiedzi = np .array ([0.0 , 1.0 ])\nna = np .array ([0.3 , 0.3 ])\nmacie = np .array ([0.8 , 0.2 ])\n\nsentence = np .array ([kot , siedzi , na , macie ])\nprint ("Przetwarzam: 'Kot siedzi na macie'" )\nfinal = simple_rnn (sentence )\nprint (f"\\nFinalny hidden state: { np . round ( final , 2 ) } " )Uruchomcie to! Zobaczycie, jak przy każdym słowie hidden state się zmienia. Ostatni hidden state to jest "rozumienie" całego zdania przez nasz prosty RNN.
Tip
\nKluczowa intuicja: Zauważcie linijkę h = np.tanh(W_h @ h + W_x @ word + bias). To jest serce RNN.
Dwie części tej linijki:
\nW_h @ h + W_x @ word + bias — to jest ta sama "suma ważona" co w perceptronie i MLP. Tyle że teraz sumuje dwa źródła: poprzedni hidden state (h) i nowe słowo (word).tanh(...) — to jest funkcja aktywacji, dokładnie ta sama rodzina co ReLU z poprzedniej sekcji. Zamiast "odcinać poniżej zera", tanh ściska wszystko do zakresu (-1, 1). Ale cel jest ten sam: złamać liniowość.Nowy hidden state zależy od dwóch rzeczy: poprzedniego hidden state (h) i nowego słowa (word). To jest dokładnie to, co robimy, czytając tekst - łączymy to, co już wiemy, z tym, co właśnie przeczytaliśmy.
I tu dochodzimy do tematu, który zmienił wszystko.
\nRNN ma pamięć, tak. Ale to jest pamięć złotej rybki.
\nWyobraźcie sobie to zdanie:
\n\n\n"To jest Jan i ma 30 lat. Lubi chodzić po górach, programować w Pythonie i grać na gitarze. Jego ulubionym kolorem jest zielony. Kiedyś chciał zostać astronautą, ale potem odkrył, że (...) [tutaj 50 słów o różnych rzeczach] (...) i dlatego ___ poszedł do szkoły muzycznej."
\n
Jaki ma być "___"? Jan. Ale żeby to wiedzieć, RNN musi pamiętać imię z początku zdania. I tu pojawia się problem: po 50+ słowach, sygnał z pierwszego słowa jest tak rozwodniony, że RNN go praktycznie nie pamięta.
\nTo jest słynny problem vanishing gradient (zanikający gradient).
\nMetafora: głuchy telefon. Gracie w głuchy telefon - pierwsza osoba szepcze wiadomość drugiej, ta trzeciej, itd. Po 10 osobach wiadomość jest trochę zniekształcona. Po 50 osobach - kompletnie nieczytelna. Po 100 osobach - ktoś mówi "kup mleko", a ostatnia osoba słyszy "łap chleb".
\nW RNN gradient (sygnał uczący) przepływa przez sieć dokładnie tak samo - krok po kroku. Przy każdym kroku jest mnożony przez jakieś wagi. Jeśli te wagi są mniejsze niż 1, to po wielu mnożeniach gradient zanika do zera. Sieć przestaje się uczyć z odległych słów.
\nA czasami jest odwrotnie - wagi są większe niż 1 i gradient rośnie eksponencjalnie (exploding gradient). Sieć "oszalała" i wartości lecą w kosmos.
\ngraph LR\n G1["Krok 1<br/>gradient = 1.0"] -->|"×0.7"| G2["Krok 2<br/>0.7"]\n G2 -->|"×0.7"| G3["Krok 3<br/>0.49"]\n G3 -->|"×0.7"| G4["Krok 4<br/>0.34"]\n G4 -->|"..."| G5["Krok 20<br/>0.001"]\n G5 -->|"..."| G6["Krok 50<br/>≈ 0"]\n \n style G1 fill:#66cc66,color:#fff\n style G2 fill:#99cc66,color:#000\n style G3 fill:#cccc66,color:#000\n style G4 fill:#cc9966,color:#000\n style G5 fill:#cc6666,color:#fff\n style G6 fill:#993333,color:#fff\nWarning
\nDlaczego to jest takie ważne? Bo język jest pełen długich zależności. "The cat, which already ate all the fish in the fridge and then slept on the couch for three hours, was happy." - żeby połączyć "cat" z "was happy", model musi przeskoczyć kilkanaście słów. RNN tego nie potrafi.
\nI wtedy w 1997 roku Sepp Hochreiter i Jürgen Schmidhuber powiedzieli: a gdyby tak dać sieci explicite mechanizm pamięci?
\nLong Short-Term Memory (LSTM) to RNN na sterydach. Zamiast jednego prostego hidden state, LSTM ma komórkę pamięci (cell state) i trzy bramki (gates), które decydują, co z tą pamięcią zrobić.
\nMetafora, która najlepiej działa: LSTM to uczeń z notatnikiem i trzema zasadami.
\nNa początku każdego kroku LSTM pyta: "co z dotychczasowej pamięci jest już nieaktualne i mogę wyrzucić?"
\nJak czytacie nowy rozdział książki, to nie potrzebujecie pamiętać, co jedli bohaterowie na śniadanie trzy rozdziały temu. Zapominacie nieistotne detale, żeby zrobić miejsce na nowe.
\nW LSTM: forget gate przepuszcza każdy element pamięci przez sigmoidę (wartości 0-1). Blisko 0 = "zapomnij". Blisko 1 = "zatrzymaj".
\nPotem LSTM pyta: "co z nowego słowa jest warte zapisania?"
\nKiedy czytacie "Mam na imię Jan" - macie refleks: "OK, to jest ważne, muszę to zapamiętać". Nie zapamiętujecie każdego słowa dosłownie, ale wybieracie to, co istotne.
\nW LSTM: input gate decyduje, które nowe informacje przepuścić do cell state.
\nNa koniec LSTM pyta: "co z mojej pamięci jest teraz istotne dla tego, co robię?"
\nJak ktoś was pyta "Jak ma na imię ta postać, o której właśnie czytaliśmy?" - sięgacie do notatnika i wyciągacie konkretne informacje. Nie pokazujecie całego notatnika - tylko to, co jest potrzebne teraz.
\ngraph TD\n subgraph "LSTM - komórka pamięci"\n CS_IN["📥 Cell state (wejście)<br/><i>taśma z informacjami</i>"] --> MUL1["✖️ × forget gate"]\n FG["🗑️ Forget gate<br/><i>co zapomnieć?</i>"] --> MUL1\n MUL1 --> ADD["➕ + nowa informacja"]\n NEW["📝 Nowa informacja<br/><i>input gate × kandydat</i>"] --> ADD\n IG["📥 Input gate<br/><i>co zapisać?</i>"] --> NEW\n ADD --> CS_OUT["📤 Cell state (wyjście)<br/><i>zaktualizowana taśma</i>"]\n CS_OUT --> TANH["tanh"]\n TANH --> MUL2["✖️ × output gate"]\n OG["📤 Output gate<br/><i>co pokazać?</i>"] --> MUL2\n MUL2 --> HS["🧠 Hidden state<br/><i>to, co 'myśli' teraz</i>"]\n end\n \n X["📖 Nowe słowo (x_t)"] --> FG & IG & OG\n HS_PREV["🧠 Poprzedni hidden state (h_{t-1})"] --> FG & IG & OG\n \n style CS_IN fill:#ffcc99,color:#000\n style CS_OUT fill:#ffcc99,color:#000\n style FG fill:#ff6666,color:#fff\n style IG fill:#66cc66,color:#fff\n style OG fill:#6666ff,color:#fff\n style HS fill:#cc99ff,color:#000\n style X fill:#ffcc99,color:#000\nKluczowa rzecz: cell state to jest ta "taśma produkcyjna" (conveyor belt). Informacja na niej może płynąć prawie niezmieniona przez wiele kroków - bramki decydują tylko, co przepuścić, co dodać i co usunąć. To rozwiązuje problem vanishing gradient, bo informacja nie musi być "mnożona" na każdym kroku - może po prostu przepłynąć.
\nNote
\nRNN vs LSTM w jednym zdaniu: RNN próbuje pamiętać wszystko, ale szybko zapomina. LSTM jest selektywne - decyduje co zachować, co zaktualizować i co pokazać. To jest różnica między "próbą zapamiętania całego wykładu słowo w słowo" a "robieniem notatek z najważniejszymi punktami".
\nJeśli chcecie zobaczyć wzory, oto one (nie musicie ich zapamiętywać, ale warto zobaczyć, że to nie jest czarna magia):
\nForget gate:\n$$f_t = \\sigma(W_f \\cdot [h_{t-1}, x_t] + b_f)$$
\nInput gate:\n$$i_t = \\sigma(W_i \\cdot [h_{t-1}, x_t] + b_i)$$
\nKandydat do cell state:\n$$\\tilde{C}t = \\tanh(W_c \\cdot [h{t-1}, x_t] + b_c)$$
\nAktualizacja cell state:\n$$C_t = f_t \\odot C_{t-1} + i_t \\odot \\tilde{C}_t$$
\nOutput gate:\n$$o_t = \\sigma(W_o \\cdot [h_{t-1}, x_t] + b_o)$$
\nHidden state:\n$$h_t = o_t \\odot \\tanh(C_t)$$
\nGdzie $\\sigma$ to sigmoid (wgniata wartości do 0-1), $\\odot$ to mnożenie element-po-elemencie, a $[h_{t-1}, x_t]$ to połączenie poprzedniego hidden state z nowym wejściem.
\nSpróbujcie sami. Odpalcie ChatGPT (albo Claude, Gemini - co macie) i wyślijcie ten prompt:
\n\n\n"Pola na imieniu miała rzadką zdolność do zapamiętywania cyfr. Jej ulubioną liczbą było 42. Lubiła też longboarding, malowanie akwarelami i granie w szachy. Jej kot wabił się Mruczka. (...) [tutaj wklejcie 3-4 akapity jakiegokolwiek tekstu - przepis na naleśniki, opis pogody, cokolwiek] (...) Mimo wszystko, to właśnie ___ postanowiła wziąć udział w konkursie matematycznym."
\n
Zobaczcie, czy model wypełni lukę poprawnie (Pola). LSTM by sobie z tym poradził. Zwykły RNN - prawdopodobnie nie. A dlaczego? Bo LSTM ma mechanizm, który mówi "zapamiętaj imię Pola - to może być ważne później". RNN po prostu... zapomniałby ;-)
\nOK, więc LSTM rozwiązało problem pamięci. Przynajmniej częściowo. Ale pojawiły się nowe problemy, które okazały się fundamentalne.
\nLSTM rozwiązało vanishing gradient w dużej mierze, ale nie całkowicie. Gdy odległość między powiązanymi słowami rośnie do setek lub tysięcy słów, nawet LSTM zaczyna gubić nić narracji. Badacze Bengio et al. (1994) pokazali, że sieci rekurencyjne - nawet z bramkami - wciąż mają problem z podtrzymaniem użytecznych gradientów na bardzo długich dystansach.
\nCzyli: zamiast zapominać po 10 słowach (RNN), LSTM zapomina po... 100? 200? Lepiej, ale wciąż nie idealnie.
\nI to jest najważniejszy problem.
\nRNN i LSTM przetwarzają dane krok po kroku. Krok 2 musi poczekać na krok 1. Krok 3 na krok 2. I tak dalej.
\ngraph LR\n S1["Krok 1"] --> S2["Krok 2"]\n S2 --> S3["Krok 3"]\n S3 --> S4["Krok 4"]\n S4 --> S5["..."]\n S5 --> S6["Krok 1000"]\nA teraz pomyślcie o GPU. GPU to jest maszynka, która uwielbia robić wiele rzeczy naraz (parallel processing). Tysiące rdzeni pracujących równocześnie.
\nAle RNN/LSTM mówi GPU: "nie, nie, poczekaj. Najpierw skończmy krok 1, dopiero potem zacznij krok 2". GPU płacze.
\nTo jest jak książka z 10 000 rozdziałów, gdzie każdy rozdział musi być przeczytany po poprzednim. Nie możecie przeczytać rozdziału 500, dopóki nie skończycie 499. Nie da się tego zrównoleglić. Przy krótkich tekstach to nie problem, ale przy trenowaniu modelu na miliardach słów? To jest koszmar.
\nLSTM ma dodatkowo 4x więcej parametrów niż prosty RNN (trzy bramki + cell state = cztery zestawy wag na każdy neuron). Więc trenuje się wolniej i zużywa więcej pamięci.
\nLSTM (jak większość modeli deep learning) jest trudny do interpretacji. Model może generować poprawne wyniki, ale trudno zrozumieć, dlaczego podjął taką a nie inną decyzję. W zastosowaniach takich jak medycyna czy finanse, gdzie interpretowalność jest kluczowa, to jest poważny problem.
\n| Architektura | \nRok | \nRozwiązuje... | \nAle nie potrafi... | \n
|---|---|---|---|
| Perceptron | \n1958 | \nKlasyfikacja liniowa | \nXOR, nieliniowość | \n
| MLP | \n1986 | \nNieliniowe relacje | \nRozumieć kolejność słów | \n
| RNN | \n1986 | \nPrzetwarzać sekwencje krok po kroku | \nPamiętać długie zależności | \n
| LSTM | \n1997 | \nPamiętać dłużej dzięki bramkom | \nPrzetwarzać równolegle, bardzo długie teksty | \n
graph LR\n P["Perceptron<br/>✅ klasyfikuje<br/>❌ tylko liniowo"] -->|"dodaj warstwy"| MLP\n MLP["MLP<br/>✅ nieliniowość<br/>❌ nie widzi kolejności"] -->|"dodaj rekurencję"| RNN\n RNN["RNN<br/>✅ sekwencje<br/>❌ zapomina"] -->|"dodaj bramki"| LSTM\n LSTM["LSTM<br/>✅ dłuższa pamięć<br/>❌ sekwencyjny = wolny"] -->|"???"| Q["<b>???</b>"]\n \n style P fill:#ff9999,color:#000\n style MLP fill:#ffcc99,color:#000\n style RNN fill:#99ccff,color:#000\n style LSTM fill:#cc99ff,color:#000\n style Q fill:#ff6666,color:#fff\nKażda generacja rozwiązywała problem poprzedniej, ale tworzyła nowy. To jest jak gra w whack-a-mole - uderzasz jednego kreta, wyskakuje następny.
\nI wtedy w 2017 roku ktoś zadał szalone pytanie...
\nMetafora, która zmienia wszystko.
\nWyobraźcie sobie, że czytacie powieść. Teraz macie trzy sposoby na to:
\nW 2017 roku grupa badaczy z Google opublikowała artykuł ze skromnym tytułem: "Attention Is All You Need". Ich szalona idea? A co jeśli w ogóle przestaniemy czytać po kolei? A co jeśli każde słowo będzie mogło "zobaczyć" wszystkie inne słowa naraz?
\nI nastąpiła rewolucja. Bo jeśli każde słowo patrzy na każde inne jednocześnie (nie czekając na swoją kolej), to:
\nTa architektura nazywa się Transformer. I to na niej są zbudowane ChatGPT, Claude, Gemini i wszystkie LLM, które znacie.
\n| Architektura | \nMetafora | \nCo potrafi | \nCzego nie umie? | \n
|---|---|---|---|
| Perceptron | \nLinijka | \nRysuje jedną linię, klasyfikuje na 2 grupy | \nXOR, nieliniowość, cokolwiek złożonego | \n
| MLP | \nZespół analityków | \nModeluje nieliniowe relacje, "głębokość" | \nNie rozumie kolejności, widzi wszystko naraz | \n
| RNN | \nCzytelnik słowo po słowie | \nPrzetwarza sekwencje, ma hidden state | \nKrótka pamięć (vanishing gradient) | \n
| LSTM | \nUczeń z notatnikiem i bramkami | \nSelekrewna pamięć, trzy bramki kontroli | \nSekwencyjny = wolny, brak parallelizacji | \n
| Transformer | \nCała strona naraz | \nRównoległość, uwaga na wszystko | \n...do odkrycia w następnych wpisach... | \n
graph TD\n subgraph "Od neuronu do LLM - droga, którą przeszliśmy"\n P["Perceptron 1958<br/>liniowa klasyfikacja"] --> MLP\n MLP["MLP 1986<br/>nieliniowość + warstwy"] --> RNN\n RNN["RNN 1986<br/>sekwencje + hidden state"] --> LSTM\n LSTM["LSTM 1997<br/>pamięć z bramkami"] --> T\n T["Transformer 2017<br/>uwaga na wszystko naraz"]\n end\n \n style P fill:#ff9999,color:#000\n style MLP fill:#ffcc99,color:#000\n style RNN fill:#99ccff,color:#000\n style LSTM fill:#cc99ff,color:#000\n style T fill:#ff6666,color:#fff\nTen wpis jest dość długi, ale czułem, że ta ewolucja od perceptronu do LSTM zasługuje na pełną, opowiedzianą historię.
\nJeśli coś jest niejasne - napiszcie w komentarzach, postaram się wyjaśnić.
\nKtóra architektura was najbardziej zaskoczyła? Czy wiedzieliście, że "AI Winter" był spowodowany czymś tak "prostym" jak XOR?
\n\n\nCo w następnym wpisie? Wchodzimy w Transformer - architekturę, która zmieniła wszystko. Attention, self-attention, positional encoding, multi-head attention - wszystko to, co sprawiło, że ChatGPT w ogóle istnieje. Stay tuned!
\n
Do następnego!
\nŹródła i ciekawe linki:
\nJeśli chcecie wejść głębiej, oto materiały, z których korzystałem:
\nOdpowiedzi do mini-quizu: 1) Liniowa - y = ax + b to funkcja liniowa. 2) Nieliniowy - funkcja step "łamie" liniowość. 3) Liniowy! Bez aktywacji nieliniowej, MLP z 100 warstwami = jedna wielka transformacja liniowa. To jest właśnie powód, dla którego funkcje aktywacji są niezbędne. ↩
\nMoje odpowiedzi: 1) Wystarczy prosty MLP - dane tabelaryczne, brak sekwencji. 2) LSTM - sekwencja o umiarkowanej długości, LSTM sobie poradzi. 3) Transformer - 10 000 słów to za dużo nawet dla LSTM. Transformer z self-attention pozwala każdemu słowu "widzieć" każde inne bez czekania. 4) Nie - pojedynczy perceptron nie rozwiąże XOR. Trzeba minimum MLP (2 warstwy). ↩
\n