· NLP

10 lat rozwoju NLP – od Bag-of-Words do Transformera (Test OpenAI DeepResearch)

Zobacz jak ewoluowały modele NLP w ciągu ostatniej dekady – od prostych reprezentacji słów, przez LSTM i mechanizm uwagi, aż po rewolucyjne Transformery. Dowiedz się, jakie innowacje zbudowały fundamenty współczesnego NLP.

TL;DR

Dowiedz się, jak historia modeli językowych zbudowała fundamenty dla Transformerów. Poznaj kluczowe kamienie milowe – od word embeddings, przez RNN i LSTM, aż po pre-train/fine-tune i gigantyczne modele, które zrewolucjonizowały NLP.

Dekada NLP wg OpenAI DeepResearch

Przetwarzanie języka naturalnego (NLP) z wykorzystaniem komputerów i sieci neuronowych to fascynujący obszar badań, który od ponad dekady rewolucjonizuje interakcje między ludźmi a maszynami. Dzięki dynamicznemu rozwojowi technik uczenia maszynowego oraz uczenia głębokiego, NLP stało się kluczowym elementem w dziedzinie sztucznej inteligencji, umożliwiając komputerom rozumienie, analizę i generowanie ludzkiego języka w sposób coraz bardziej naturalny i efektywny.

W dzisiejszym tekście analizujemy ostatnie 10 lat rozwoju tego obszaru badań nad sztuczną inteligencją, skupiając się na kluczowych osiągnięciach, wyzwaniach oraz przyszłych kierunkach pracy w domenie NLP.

Co ważne, do stworzenia tego artykułu wykorzystaliśmy niedawno zaprezentowaną usługę o nazwie OpenAI DeepResearch w planie ChatGPT Pro, dzięki której możliwe było przeprowadzenie dogłębnych analiz i syntez informacji z licznych źródeł internetowych. DeepResearch autonomicznie przeszukuje, analizuje i konsoliduje dane z sieci, dostarczając kompleksowych raportów na zadane tematy.

Artykuł spełnia dwie funkcje – z jednej strony jest to omówienie ostatniej dekady postępów w NLP, a z drugiej demonstracja możliwości nowoczesnych narzędzi badawczych opartych na sztucznej inteligencji, takich jak DeepResearch. Na końcu artykułu znajduje się krótki opis kroków, przez które przeszliśmy tworząc ten artykuł z ChatemGPT. Staraliśmy się, aby ingerencja w treść była minimalna, więc zarówno poszczególne rozdziały jak i błędy czy literówki służą za podstawę recenzji funkcji DeepResearch i nie ukrywamy tego.

Zapraszamy do czytania!


Najważniejsze osiągnięcia NLP (2013–2025)

Natural Language Processing (NLP) w ostatniej dekadzie przeszedł ogromną ewolucję – od prostych modeli reprezentacji słów, przez wyspecjalizowane sieci sekwencyjne, po gigantyczne modele językowe zdolne do złożonego rozumowania. Poniżej przedstawiamy chronologiczny przegląd kluczowych osiągnięć NLP z lat 2013–2025. Artykuł ten kierujemy do doświadczonych programistów, którzy nie są ekspertami od NLP – staramy się zatem wyjaśnić terminologię, zbudować intuicje (np. poprzez analogie) i zilustrować koncepcje prostymi przykładami (również kodu w Pythonie). Każda sekcja zawiera kontekst historyczny, opis działania modelu, przykłady zastosowań (z fragmentami kodu) oraz omówienie ograniczeń i otwartych problemów badawczych. Dla dociekliwych dołączamy odniesienia do literatury naukowej (głównie ArXiv, publikacje konferencyjne i blogi ekspertów), aby ułatwić dalsze zgłębianie tematu.

1. Word2Vec (2013) – ciągłe reprezentacje słów

Kontekst i motywacja: W początkach dekady 2010+ modele NLP często reprezentowały słowa jako jednowymiarowe indeksy (np. „kot” = ID 537), co nie oddawało żadnej informacji o podobieństwie między słowami. Alternatywą były wektory częstotliwości (wystąpień słów w kontekście innych słów) redukowane metodami statystycznymi (np. LSA) – te jednak były wysokowymiarowe i trudno było je trenować na bardzo dużych korpusach. Przełom nastąpił w 2013 roku, gdy zespół Thomasa Mikolova z Google zaproponował Word2Vec – metody uczące każde słowo ciągłej reprezentacji wektorowej (tzw. embedding) w stosunkowo niskowymiarowej przestrzeni (setki wymiarów) ([1301.3781] Efficient Estimation of Word Representations in Vector Space). Word2Vec pozwolił trenować takie wektory na miliardach słów w ciągu godzin, a uzyskane reprezentacje uchwyciły zaskakująco wiele relacji semantycznych i składniowych między słowami (Źródło) (Źródło). Na przykład odpowiednio wytrenowany model spełniał słynne równanie: wektor(“król”) - wektor(“mężczyzna”) + wektor(“kobieta”) ≈ wektor(“królowa”) – czyli model „rozumiał”, że królowa to jak król, ale płci żeńskiej (Źródło).

Mechanizm działania: Word2Vec występuje w dwóch wariantach architektury: CBOW oraz Skip-gram (Źródło). Obie to proste jedoukładowe sieci neuronowe (bez ukrytych warstw) uczone zadania kontekstowego:

  • CBOW (Continuous Bag-of-Words) przewiduje bieżące słowo na podstawie sąsiadujących słów w zdaniu. Mówiąc obrazowo, dostaje na wejściu kilka słów z kontekstu (poprzednich i następnych) i uczy się jakie słowo pasuje w lukę (Źródło).
  • Skip-gram robi odwrotnie: dostaje jedno słowo i stara się przewidzieć, jakie słowa zazwyczaj pojawiają się w jego otoczeniu (Źródło).

W obu przypadkach trenowanie polega na tym, by wektory (embeddingi) słów były tak dobrane, że słowa występujące w podobnych kontekstach będą miały do siebie podobne wektory. Intuicyjnie: model stara się, aby np. “pies” i “kot” miały zbliżone reprezentacje, bo oba mogą pojawiać się w podobnych zdaniach, natomiast “pies” i “samochód” powinny się różnić. Technicznie, trenowanie odbywa się metodą optymalizacji stochastycznej: losujemy słowo i jego kontekst z korpusu tekstów, po czym aktualizujemy parametry modelu (wektory) tak, by zwiększyć prawdopodobieństwo poprawnej predykcji. Kluczowym usprawnieniem okazało się wprowadzenie negatywnego próbkowania (negative sampling) – zamiast kosztownej normalizacji po całym słowniku, model uczy się rozróżniać prawdziwe konteksty od losowych „negatywnych” przykładów (Źródło) (Źródło). Dzięki temu trenowanie jest bardzo efektywne nawet dla milionów słów słownika (Źródło) (Źródło).

Przykład (Python): Poniżej zilustrowano, jak można wytrenować prosty model Skip-gram za pomocą biblioteki Gensim na małym zbiorze zdań i następnie sprawdzić podobieństwo między wektorami kilku słów:

from gensim.models import Word2Vec

# Przykladowe zdania (korpus treningowy)
sentences = [
    ["kot", "je", "rybę"],
    ["pies", "je", "kość"],
    ["kot", "lubi", "mleko"],
    ["pies", "goni", "kota"],
]
# Trening modelu Skip-gram (sg=1) o wektorach 10-wymiarowych
model = Word2Vec(sentences, vector_size=10, window=2, sg=1, min_count=1, epochs=100)

vec_kot = model.wv["kot"]
vec_pies = model.wv["pies"]
print("Wektor 'kot':", vec_kot)
print("Podobieństwo 'kot' vs 'pies':", model.wv.similarity("kot", "pies"))

W wyniku otrzymujemy wektory (embeddingi) – ciągi liczb zmiennoprzecinkowych – oraz miarę podobieństwa kosinusowego między nimi. Dla dobrze wytrenowanego modelu na dużym korpusie wektor “kot” będzie bliski wektorowi “pies”, natomiast odległy od wektora “ryba” czy “samochód”. Takie wektory mogą potem zasilać inne algorytmy – Word2Vec stał się fundamentem dla wielu aplikacji NLP, dostarczając „zrozumiałe” dla komputerów reprezentacje znaczenia słów.

Zastosowania: Word2Vec szybko znalazł zastosowanie w praktycznie wszystkich zadaniach NLP. Embeddingi słów zaczęto wykorzystywać w klasyfikacji tekstu (np. rozpoznawanie spamu, analiza sentymentu), systemach pytanie-odpowiedź, tłumaczeniach maszynowych i wielu innych. Zaletą było to, że po jednorazowym wytrenowaniu na dużym korpusie (np. Wikipedia, Google News) wektory można było wczytać i użyć w dowolnym modelu jako gotową warstwę wejściową, skracając czas treningu i poprawiając wyniki (model uczył się szybciej dzięki wstępnej wiedzy o podobieństwach słów). Popularnym źródłem stały się pretrenowane modele Word2Vec udostępniane przez Google – np. wektory 300-wymiarowe dla 3 milionów angielskich słów. Dla innych języków, w tym polskiego, społeczność również przygotowała podobne zasoby.

Ograniczenia: Mimo przełomowości, Word2Vec ma istotne ograniczenia. Najważniejsze z nich to:

  • Brak kontekstu zdaniowego: Każde słowo ma jeden wektor, niezależnie od kontekstu. To oznacza, że jeśli słowo ma wiele znaczeń (polisemia, np. “zamek” jako budowla obronna vs. “zamek” błyskawiczny), Word2Vec nie rozróżni ich – dostaniemy pewną uśrednioną reprezentację. Model nie „wie”, które znaczenie jest użyte w danym zdaniu, bo embedding jest stały. To ograniczenie próbowano łagodzić później, np. trenowaniem osobnych wektorów dla poszczególnych sensów słów lub opracowaniem kontekstowych modeli (o czym dalej).
  • Ograniczony zakres zależności: Skip-gram i CBOW uczą się na oknach kontekstowych rzędu kilku słów. Nie łapią więc długodystansowych zależności w zdaniu – np. zależności podmiot-orzeczenie oddalone o wiele słów. W praktyce to oznacza, że embeddingi Word2Vec dobrze oddają relacje semantyczne między pojedynczymi słowami, ale nie potrafią reprezentować znaczenia całych zdań ani rozumieć składni.
  • Ignorowanie struktury wewnętrznej słów: W oryginalnym Word2Vec każde słowo jest jednostką atomową – model nie wykorzystuje faktu, że np. “koty” i “kot” mają wspólny rdzeń. To problem zwłaszcza w językach o bogatej morfologii (polski, turecki itp.) i dla rzadkich słów. Rozwiązaniem stały się dopiero modele uwzględniające sub-słowne jednostki (np. model FastText dodający wektory dla n-gramów znakowych, co pozwala lepiej radzić sobie z odmianami i słowami nieznanymi (Źródło) (Źródło)).

Wpływ i dalszy rozwój: Word2Vec zapoczątkował lawinę prac nad lepszymi reprezentacjami języka. W kolejnych latach pojawiły się modyfikacje (np. wspomniany FastText wzbogacający embeddingi o informacje o morfologii (Źródło)) oraz zupełnie nowe podejścia, które próbowały przezwyciężyć brak kontekstowości – najpierw modele dwukierunkowe LSTM generujące embeddingi kontekstowe (np. ELMo, 2018), a następnie architektury transformatorowe, które doprowadziły do powstania modeli pokroju BERT (2018) czy GPT (2018+). Zanim do nich przejdziemy, przyjrzyjmy się jednak kolejnemu kamieniowi milowemu – modelom sekwencyjnym LSTM, które umożliwiły jakościowy skok w zadaniach przetwarzania ciągów słów.

2. LSTM (2014) – głębokie modelowanie sekwencji z pamięcią długotrwałą

Kontekst i motywacja: Wiele istotnych zadań NLP wymaga przetwarzania całych sekwencji słów, a nie tylko pojedynczych wyrazów. Przykładowo, by stwierdzić, czy zdanie jest pytaniem, musimy spojrzeć na jego koniec; by przetłumaczyć zdanie, musimy zrozumieć wszystkie jego części. Rekurencyjne Sieci Neuronowe (RNN) były naturalnym wyborem do takich zadań, bo przetwarzają sekwencje słowo po słowie, zapamiętując stan (wektor ukryty) niosący informację o wcześniejszych elementach. Niestety, proste RNN (np. model Elmana) mają problem z tzw. zanikającym gradientem – im dalsze zależności (dłuższe sekwencje) próbujemy uchwycić, tym trudniej je wytrenować. W praktyce, klasyczne RNN „pamiętały” tylko bardzo krótki kontekst (kilka ostatnich słów); gdy istotna informacja była dużo wcześniej, sieć często jej nie wykorzystała (Understanding LSTM Networks — colah’s blog) (Understanding LSTM Networks — colah’s blog). Przykładowo, model językowy RNN może mieć trudność, by poprawnie przewidzieć zaimek w zdaniu “Janek pojechał do Berlina… tam …”, bo wymaga to pamiętania podmiotu z początku zdania.

Rozwiązaniem okazała się architektura LSTM (Long Short-Term Memory), zaproponowana już w 1997 r. przez Hochreitera i Schmidhubera (Understanding LSTM Networks — colah’s blog), jednak jej prawdziwa popularyzacja nastąpiła około 2014 roku. To wtedy dzięki zwiększonej mocy obliczeniowej i udoskonaleniom algorytmicznym LSTM zaczęły dominować w zadaniach typu modelowanie języka, translacja maszynowa, rozpoznawanie mowy itp. LSTM to pewien rodzaj komórki rekurencyjnej zaprojektowanej wprost po to, by radzić sobie z długimi zależnościami – jej architektura ułatwia przekazywanie informacji na długich odcinkach sekwencji (Understanding LSTM Networks — colah’s blog) (Understanding LSTM Networks — colah’s blog). Jak ujęto obrazowo w jednym z blogów: “LSTMs are explicitly designed to avoid the long-term dependency problem. Remembering information for long periods is practically their default behavior” (Understanding LSTM Networks — colah’s blog) – LSTM z założenia pamięta istotne rzeczy znacznie lepiej niż proste RNN.

Jak działa LSTM – pamięć i bramki: Kluczowym pomysłem LSTM jest wprowadzenie stanu komórki (cell state) (Ct), który pełni rolę długoterminowej pamięci przepływającej przez kolejne kroki czasowe. Ten stan może przenosić informacje daleko, z niewielkimi tylko liniowymi zmianami – co zapobiega zanikaniu sygnału. Jednak żeby ta pamięć nie “przenosiła wszystkiego” (co prowadziłoby do przepełnienia lub zniekształcenia), LSTM posiada specjalne bramki (gates) – małe sieci neuronowe (warstwy sigmoid) decydujące, które informacje zachować, które dodać, a które usunąć ze stanu. Można je porównać do _zaworów kontrolujących przepływ informacji w pamięci:

  • Bramka zapominania (forget gate): Otrzymuje jako wejście poprzedni stan ukryty (h*{t-1}) oraz bieżące wejście (x_t) i na tej podstawie *dla każdej składowej stanu komórki (C*{t-1}) wypisuje wartość od 0 do 1* – 1 oznacza „całkowicie zatrzymaj tę informację”, 0 – „wymaż ją” (Understanding LSTM Networks — colah’s blog) (Understanding LSTM Networks — colah’s blog). W ten sposób model może zapomnieć nieaktualne już informacje. Np. czytając zdanie: “Ala ma kota. Ona go kocha.”_, gdy zaczyna się nowe zdanie, LSTM może zapomnieć płeć poprzedniego podmiotu, bo pojawia się nowy podmiot (w tym przypadku jednak zaimek _“ona” wskazuje, że *Ala* jest dalej ważna – to subtelny przypadek koreferencji, ale ilustruje mechanizm).
  • Bramka wejścia (input gate) i kandydat: Decyduje, które nowe informacje z bieżącego wejścia należy dodać do stanu pamięci. Składa się z dwóch elementów: warstwy sigmoid (it), która wskazuje, które składowe _powinny zostać zaktualizowane, oraz warstwy tanh generującej wektor proponowanych nowych wartości (\tilde{C}_t) (Understanding LSTM Networks — colah’s blog). Na podstawie tego LSTM później dołącza nowe informacje do stanu. Przykład: przetwarzając zdanie, gdy pojawia się nowy podmiot, bramka wejścia przepuści informację o nim (np. “nowy podmiot = Ala”) do stanu, żeby model pamiętał go na przyszłość (Understanding LSTM Networks — colah’s blog).
  • Aktualizacja stanu: Po ustaleniu przez powyższe bramki co zapomnieć i co dodać, następuje właściwa aktualizacja: stare (C_{t-1}) jest mnożone przez wektor zapominania (f_t) (czyli niektóre wartości wygaszane), a następnie dodawany jest (i_t * \tilde{C}_t), czyli nowe informacje tam, gdzie bramka wejścia pozwoliła (Understanding LSTM Networks — colah’s blog). Otrzymujemy nowy stan komórki (C_t). To etap, w którym np. zapominamy poprzedni temat zdania, a zapisujemy nowy.
  • Bramka wyjścia (output gate): Kontroluje, co z wewnętrznego stanu (Ct) ujawnić na zewnątrz jako _stan ukryty (ht) (który będzie używany do przewidywania wyjścia oraz przekazywany do następnego kroku) (Understanding LSTM Networks — colah’s blog). Działa to tak, że sigmoid (o_t) wybiera, które części (C_t) są istotne na wyjściu, następnie (C_t) jest przepuszczone przez tanh (skompresowane do (-1..1)) i _przemnożone przez (ot). Innymi słowy, bramka wyjścia decyduje, jaką informację _wyemitować z komórki w danym kroku (Understanding LSTM Networks — colah’s blog). Przykładowo, jeśli model generuje zdanie i właśnie przeczytał podmiot, to może wypuścić informację o liczbie pojedynczej, żeby następnie dobrać poprawną formę orzeczenia.

Dzięki takiej konstrukcji LSTM potrafi przechowywać pewne zmienne w stanie komórki przez wiele kroków – np. zapamiętać rodzaj podmiotu aż do momentu, gdy będzie potrzebny przy odmienianiu orzeczenia w dalszej części zdania. W zwykłym RNN taka informacja szybko by się “rozmyła”. W LSTM mechanizmy bramek uczą się ochraniać ją tak długo, jak jest przydatna. W efekcie model może efektywnie uczyć się zależności na długich sekwencjach. W literaturze mówi się, że LSTM ma pamięć długotrwałą (stan komórki) i krótkotrwałą (stan ukryty), gdzie krótkotrwała odpowiada bardziej za aktualne przetwarzanie, a długotrwała przenosi wiedzę w czasie.

Przykład (Python): Poniżej przykład użycia LSTM w PyTorch do przetworzenia sekwencji wejściowej. Stworzymy prostą sieć z warstwą LSTM i pokażemy, jak krok po kroku buduje ona stan ukryty dla kolejnych elementów sekwencji. (Ten przykład jest demonstracyjny – w praktyce skorzystamy z wyższych poziomów API, ale tutaj rozpisujemy go dla ilustracji.)

import torch
import torch.nn as nn

# Definiujemy LSTM: wejście ma rozmiar 5, ukryty stan rozmiaru 3, jedna warstwa
lstm = nn.LSTM(input_size=5, hidden_size=3, num_layers=1, batch_first=True)

# Przykładowa sekwencja wejściowa: sekwencja 4 kroków, każdy reprezentowany wektorem 5d
seq = torch.tensor([[
    [1.0, 0.5, 0.0, 0.0, 0.0],   # krok 1
    [0.9, 0.1, 0.0, 0.0, 0.0],   # krok 2
    [0.0, 0.0, 1.0, 0.5, 0.0],   # krok 3
    [0.0, 0.0, 0.9, 0.1, 0.0]    # krok 4
]], dtype=torch.float)

# Inicjalizujemy h0 i c0 (stan ukryty i stan komórki) zerami
h0 = torch.zeros(1, 1, 3)
c0 = torch.zeros(1, 1, 3)
# Przepuszczamy sekwencję przez LSTM
output, (hn, cn) = lstm(seq, (h0, c0))
print("Wyjście LSTM dla każdego kroku:\n", output)
print("Stan ukryty po ostatnim kroku (h_n):", hn)
print("Stan komórki po ostatnim kroku (c_n):", cn)

Wynikiem output będzie tensor kształtu (1, 4, 3) – dla każdego z 4 kroków LSTM zwróci 3-wymiarowy wektor wyjściowy (stan ukryty). hn i cn to stany ukryty i komórki po ostatnim kroku (tu są identyczne z output dla ostatniego kroku, ponieważ mamy jedną warstwę). Gdybyśmy kontynuowali sekwencję, użyjemy hn, cn jako h0, c0 do następnej części. W ten sposób LSTM „niesie pamięć” przez sekwencję.

Zastosowania: LSTM zrewolucjonizowały podejście do problemów sekwencyjnych. W NLP około 2014-2017 były wszędzie:

  • Modele języka: LSTM trenowane na duzych korpusach do przewidywania kolejnego słowa biły rekordy w miarach takich jak perpleksja (miara jakości modelu języka). Karpathy w 2015 pokazał słynne eksperymenty, gdzie LSTM generowały sensowne ciągi tekstu ucząc się struktury nawiasów czy cudzysłowów w tekstach programów czy sonetów Szekspira (Understanding LSTM Networks — colah’s blog) (Understanding LSTM Networks — colah’s blog).
  • Translacja maszynowa: Google w 2016 zastąpiło swój tłumacz oparty o frazy na system oparty o seq2seq LSTM (patrz następna sekcja). LSTM jako enkoder i dekoder zdań pozwoliły tłumaczyć całe zdania w sposób płynniejszy i bardziej poprawny niż poprzednie systemy statystyczne.
  • Inne: Podpisy obrazów (image captioning), analiza sentimentu całych zdań/recenzji, rozpoznawanie mowy (modele akustyczne w systemach ASR), generowanie muzyki – wszędzie tam LSTM osiągały świetne wyniki, bo potrafiły modelować długie zależności. Nawet poza NLP, w szeregach czasowych (prognozowanie) czy robotyce, LSTM stały się popularne.

Ograniczenia: Mimo zalet, LSTM mają też słabe strony:

  • Sekwencyjność = brak możliwości równoległego przetwarzania: LSTM, podobnie jak inne RNN, przetwarza dane krok po kroku – następny stan liczy się na podstawie poprzedniego. To oznacza, że nie da się zrównoleglić obliczeń po długości sekwencji. W praktyce, dla bardzo długich sekwencji (dokumenty, transkrypty) i/lub bardzo dużych zbiorów danych, trenowanie LSTM jest wolne w porównaniu do modeli, które można liczyć równolegle (np. Transformerów – o nich później). To zainspirowało poszukiwania architektur sekwencyjnych, które da się trenować szybciej.
  • Ograniczona pamięć jednak istnieje: Choć LSTM radzi sobie z dłuższym kontekstem niż zwykłe RNN, nie jest prawdą, że „pamięta arbitralnie długo”. W praktyce LSTM też mają pewien zakres, po którym mogą zapominać. Jeśli kluczowa informacja pojawiła się np. 200 słów temu, LSTM może mieć trudność, by dalej miała duży wpływ na obecne działanie (chyba że pojawiała się po drodze, wzmacniając ślad). W zastosowaniach jak długie dialogi czy analiza całego rozdziału tekstu – LSTM mogą wymagać trików (np. dzielenia kontekstu na mniejsze fragmenty, resetowania stanu, itp.).
  • Trudność w trenowaniu bardzo głębokich sieci: LSTM to w zasadzie moduł, który można składać w warstwy (np. 3-warstwowe LSTM, gdzie wyjście jednej warstwy idzie jako sekwencja do następnej). Jednak bardzo głębokie i długie LSTM mogą być trudne do wytrenowania (choć istnieją prace radzące sobie z tym). Zanim era Transformerów przejęła pałeczkę, opracowano też prostsze warianty jak GRU (Gated Recurrent Unit) – komórka zbliżona do LSTM, lecz z nieco uproszczonymi bramkami. GRU również popularyzowały się od 2014 jako lżejsza alternatywa LSTM, często o porównywalnej skuteczności.

Podsumowanie: Architektura LSTM rozwiązała praktyczne problemy trenowania RNN na długich sekwencjach i stała się kręgosłupem nowoczesnych systemów sekwencyjnych w połowie lat 2010. Była to pierwsza generacja modeli, które naprawdę nauczyły się “rozumieć” całe zdania, a nie tylko słowa w izolacji. Otworzyło to drogę do jeszcze bardziej złożonych modeli sekwencyjnych, jak architektury encoder-decoder dla tłumaczeń czy bardziej zaawansowane mechanizmy uwagi.

3. Seq2Seq (2015) – sekwencja na sekwencję, enkoder-dekoder, mechanizm uwagi

Kontekst i motywacja: Wiele zadań NLP to przekształcenie jednej sekwencji tekstu w inną sekwencję. Przykłady:

Architektura Encoder-Decoder: Podstawowy model seq2seq składa się z dwóch części:

  • Enkoder: Sieć (np. LSTM) czytająca sekwencję wejściową token po tokenie i przekształcająca ją do pewnej wewnętrznej reprezentacji (np. ostatni stan ukryty, lub sekwencja stanów).
  • Dekoder: Druga sieć (np. LSTM) generująca sekwencję wyjściową, karmiona poprzednimi wygenerowanymi tokenami, i (ważne) inicjalizowana informacją z enkodera.

W najprostszym wariancie enkoder LSTM czyta całe zdanie źródłowe i jego ostatni stan ukryty (czasem wraz ze stanem komórki) przekazywany jest jako stan początkowy dekodera. Można to interpretować tak: enkoder koduje znaczenie całego zdania źródłowego w wektorze (zwanym nieraz wektorem kontekstowym albo myślowym), a dekoder dostaje ten „myśl” i ma ją wypowiedzieć w języku wyjściowym. Dekoder generuje wyjście sekwencyjnie: na starcie otrzymuje specjalny token startu „<BOS>”, produkuje pierwsze słowo, potem to słowo idzie na wejście z powrotem i generowane jest kolejne, i tak dalej aż do tokenu końca „<EOS>”. Trenuje się to end-to-end: minimalizując błąd przewidywania kolejnych słów wyjściowych, z wykorzystaniem standardowej propagacji wstecznej przez całą pętlę.

Mechanizm uwagi (attention): W praktyce okazało się, że przekazanie tylko jednego wektora kontekstu z enkodera do dekodera jest niewystarczające, zwłaszcza dla długich sekwencji. Mechanizm uwagi radykalnie to ulepsza. Zamiast używać tylko ostatniego stanu enkodera, przechowujemy wszystkie stany ukryte enkodera ((h1, h_2, …, h_T)) dla kolejnych tokenów źródła. Dekoder zaś w _każdym kroku generowania może dynamicznie wybrać, na które fragmenty wejścia chce zwrócić uwagę. Realizuje to poprzez obliczenie wag uwagi: dla bieżącego stanu dekodera (st) liczona jest _relewancja każdego stanu enkodera (h_i) (np. poprzez proste iloczyny skalarne lub małą sieć neuronową) i na tej podstawie powstaje rozkład wag (softmax) nad słowami źródłowymi ([1409.0473] Neural Machine Translation by Jointly Learning to Align and Translate). Te wagi określają, które słowa źródła są najważniejsze przy generowaniu aktualnego słowa wyjściowego. Następnie tworzy się tzw. wektor kontekstu jako ważoną sumę stanów enkodera z tymi wagami. Ten wektor kontekstu – dynamicznie wyliczony dla każdego kroku – staje się dodatkowym wejściem do dekodera (łączony z (s_t) lub wykorzystywany w formule decyzyjnej).

W tłumaczeniu znaczy to, że np. gdy dekoder ma wygenerować drugie słowo po francusku, może zwrócić uwagę na trzecie słowo angielskiego zdania, bo akurat ono jest tłumaczone w tej pozycji. Mechanizm uwagi jest zbliżony do ludzkiego “spojrzenia” tłumacza na oryginał podczas pisania przekładu. Formalnie Bahdanau et al. nazwali to soft alignment – miękkie dopasowanie między pozycjami wejścia i wyjścia ([1409.0473] Neural Machine Translation by Jointly Learning to Align and Translate). Ich model jednocześnie uczył się tłumaczyć i dokonywać tego dopasowania, a okazało się, że wyuczone wagi uwagi często pokrywają się z intuicyjnymi powiązaniami słów (np. w tłumaczeniu “the house” → “das Haus”, model nauczył się kierować uwagę tak, że “the” mapuje się głównie na “das”, a “house” na “Haus”, zgodnie z oczekiwaniami).

Przykład (Python): Trening pełnego modelu seq2seq z uwagą wykracza poza ramy tego artykułu, ale możemy zilustrować prosty przepływ enkoder-dekoder za pomocą wysokopoziomowych bibliotek. Użyjemy tu zestawu torchtext lub transformers. Dla zwięzłości posłużymy się gotowym małym modelikiem tłumaczącym z angielskiego na francuski (MarianNMT).

from transformers import pipeline

# Wykorzystamy pretrenowany model MarianMT do tłumaczenia EN->FR
translator = pipeline("translation_en_to_fr", model="Helsinki-NLP/opus-mt-en-fr")
result = translator("Deep learning is revolutionizing natural language processing.")
print(result[0]['translation_text'])

Ten kod użyje modelu sekwencja-na-sekwencję (w tym przypadku transformera Marian, ale koncepcyjnie podobnego do seq2seq) i przetłumaczy zdanie na francuski. Wewnątrz działa właśnie mechanizm enkodera-dekodera z uwagą: enkoder czyta angielskie zdanie i produkuje wektory, dekoder generuje francuskie słowa zwracając uwagę na odpowiednie części wejścia.

Zastosowania: Architektura seq2seq była ogromnym krokiem naprzód dla wszystkich zadań typu transdukcja sekwencji. Najpierw zdominowała tłumaczenie maszynowe: już w 2016 Google zastąpiło swój system SMT (statistical machine translation) siecią seq2seq LSTM z uwagą, nazywając to GNMT (Google Neural Machine Translation). Jakość tłumaczeń wyraźnie się poprawiła – zniknęło wiele “drewnianych” błędów, tłumaczenia stały się bardziej płynne. Następnie seq2seq znalazł zastosowanie w:

  • Streszczaniu (summarization): Model enkoder (czytający cały artykuł) + dekoder (generujący streszczenie). Mechanizm uwagi pomaga wybrać, które części artykułu są ważne by trafić do podsumowania.
  • Dialogach i generowaniu odpowiedzi: Np. modele typu chatbot mogły traktować poprzednią wypowiedź jako sekwencję wejściową, a następną jako wyjściową. Enkoder-dekoder uczy się udzielać odpowiedzi. (W praktyce do dialogów dochodzą komplikacje, ale seq2seq stało się bazą).
  • Przekształcenia formatów: Np. transliteracja (zamiana pisma), konwersja między formalnym a potocznym językiem, itp. – wszystko to da się ubrać w formę seq2seq.
  • Systemy pytanie-odpowiedź (Q&A): W pewnym uproszczeniu można traktować pytanie jako sekwencję wejściową, a odpowiedź jako wyjściową. W połączeniu z uwagą model może „skupić się” na kluczowych słowach pytania przy generowaniu odpowiedzi (choć w Q&A często łączy się to z czytaniem dokumentu – bardziej złożony temat).

Ograniczenia i rozwój: Modele seq2seq na bazie RNN (LSTM/GRU) z uwagą ustawiły nowy paradygmat, ale wkrótce pojawiły się ich ulepszenia i nowe wyzwania:

  • Trening takich modeli wymaga sporo danych i mocy. Mimo uwagi, bardzo długie sekwencje (np. całe paragrafy) nadal stanowiły wyzwanie dla RNN.
  • Uwaga „naprawiła” wiele problemów z zapamiętywaniem długich zdań, ale teoretycznie ma kwadratową złożoność (porównuje każde słowo z każdym innym przy obliczaniu wag). Dla typowych długości zdań to bez problemu, ale pytanie brzmiało: czy można jeszcze lepiej?.

Odpowiedzią okazała się architektura Transformera (2017), która wyeliminowała RNN całkowicie na rzecz mechanizmu uwagi zastosowanego w sprytny, zrównoleglony sposób. Transformer wyniósł ideę seq2seq na nowe wyżyny – docelowo wypierając LSTM w większości zastosowań NLP. Zanim jednak do niego przejdziemy (w kontekście BERT i GPT), warto wspomnieć, że sam mechanizm uwagi z prac Bahdanau i innych stał się kanwą do wszystkich późniejszych modeli. Transformery to nic innego jak wielowarstwowe mechanizmy uwagi + proste sieci feed-forward, ale zaprojektowane tak, by trenować się szybciej i efektywniej na równoległych maszynach.

Podsumowując, seq2seq z uwagą pokazało, że można uczyć modele do kompleksowych zadań typu wejście-wyjście end-to-end, bez dzielenia na pipeline z osobnymi modułami. Model sam nauczył się „które części wejścia odpowiadają którym częściom wyjścia” (soft-alignments) – coś, co dawniej trzeba było robić ręcznie (np. algorytmami dopasowania w tłumaczeniu). To przybliżyło nas do uniwersalnych modeli językowych, które z czasem przerodziły się w pretrenowane modele ujednolicone (jak T5) – o czym w dalszych sekcjach.

4. BERT (2018) – transformery, dwukierunkowy kontekst, wpłw na NLP

Kontekst: Pojawienie się Transformera (Vaswani et al., 2017) – modelu opartego w całości na mechanizmie uwagi i umożliwiającego pełną równoległość obliczeń po sekwencji – zainicjowało nową erę w NLP. Na bazie architektury transformera zaczęto budować duże pretrenowane modele językowe. W 2018 roku nastąpił prawdziwy przełom: BERT (Bidirectional Encoder Representations from Transformers) pokazał, jak skutecznie pretrenować głęboki model transformatorowy, który potem można dostosować do wielu różnych zadań NLP bijąc rekordy dokładności. Autorzy BERT (Devlin et al., Google) zademonstrowali, że pojedynczy model może po pretrenowaniu osiągnąć stan-of-the-art w szerokim wachlarzu testów (GLUE – zbiór testów zrozumienia języka, SQuAD – pytania do tekstu, itd.) ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding). Efekt BERT-a na społeczność NLP porównuje się do „trzęsienia ziemi” – od jego publikacji architektura ta (i jej pochodne) stały się podstawą prawie wszystkich nowych rozwiązań.

Czym jest BERT? Jest to transformerowy model językowy trenujący kontekstowe reprezentacje słów. Ważne cechy:

  • Dwukierunkowy kontekst: W przeciwieństwie do wcześniejszych modeli językowych, które czytały tekst w jednym kierunku (np. left-to-right jak GPT-1) lub łączyły dwa niezależne kierunki (ELMo 2018), BERT jednocześnie wykorzystuje kontekst z lewej i z prawej strony dla każdego słowa. Innymi słowy, embedding słowa w BERT zależy od całego zdania, zarówno poprzedzających, jak i następujących słów ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding). To jest możliwe dzięki architekturze transformera (konkretnie transformera-enkodera), gdzie mechanizm self-attention nie ma uprzedzeń kierunkowych – każdy token może „patrzeć” na każdy inny w warstwie. BERT został zaprojektowany, by „jointly condition on both left and right context in all layers” ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding), co było dużą zmianą względem tradycyjnych modeli (np. modeli językowych predykcyjnych). Dzięki temu BERT potrafi np. uchwycić różnicę między “bank” jako instytucją finansową a “bank” jako brzegiem rzeki, na podstawie słów po obu stronach tego słowa w zdaniu.
  • Trening przez maskowanie (Masked Language Model): Jak nauczyć model dwukierunkowy? Klasyczne trenowanie modeli językowych to przewidywanie następnego słowa (co wymusza kierunkowość). BERT natomiast wprowadza zadanie maskowania: losowo maskuje pewien procent tokenów wejściowych i każe modelowi je odgadnąć ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding). To tzw. MLM – Masked Language Modeling. Model dostaje np. zdanie: „Ala ma [MASK] kota” i ma przewidzieć, że w miejscu [MASK] powinno być “psa” (jeśli pełne zdanie brzmiało “Ala ma psa i kota”). Ponieważ maski mogą być wszędzie, model uczy się wykorzystywać pełny kontekst. Technicznie, BERT maskuje 15% losowych tokenów w tekście podczas treningu ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding), i stara się je zrekonstruować. To przypomina klasyczne zadanie Cloze z teorii testów językowych ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding).
  • Task NSP (Next Sentence Prediction): Oryginalny BERT miał jeszcze drugie zadanie podczas pretreningu: określać, czy dane zdanie jest kontynuacją innego zdania, czy pochodzi z innego miejsca. W trakcie treningu czasem podawano modelowi parę zdań, które występowały kolejno w oryginalnym tekście, a czasem zdanie losowe jako drugie – model uczył się rozpoznawać prawdziwą kontynuację. Celem NSP było nauczenie model pewnego pojęcia spójności międzyzdaniowej (choć później dyskutowano, czy NSP na pewno pomaga – w modelach pokroju RoBERTa z 2019 z tego zrezygnowano).

Architektura: BERT to w zasadzie stos N warstw enkodera transformera. W oryginale BERT base miał 12 warstw, BERT large – 24 warstwy. Każda warstwa ma mechanizmy wielogłowej uwagi (self-attention) i sieci feed-forward. Transformery przyjmują tokeny wraz z embeddingami pozycyjnymi (by wiedzieć, na jakiej pozycji jest słowo, skoro uwaga nie ma wbudowanego pojęcia kolejności). BERT dodatkowo używa specjalnego tokenu [CLS] na początek każdego ciągu (służy on potem jako ogólna reprezentacja zdania, np. do klasyfikacji) oraz [SEP] do rozdzielania dwóch zdań w input. Po pretreningu, uzyskujemy model, który dla dowolnego zdania potrafi wygenerować bardzo bogate, kontekstowe reprezentacje – każdemu słowu przyporządkowany jest wektor zależny od całego zdania. Wektor [CLS] zawiera z kolei uogólnioną informację o całym zdaniu.

Fine-tuning: Ogromna zaleta BERT-a to prostota dostosowania do różnych zadań. Devlin et al. pokazali, że wystarczy dołożyć cienką warstwę wyjściową (np. jedną warstwę liniową) nad BERT i trenować całość na konkretnym zadaniu przez parę epok, by osiągać najlepsze wyniki ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding). Przykładowo:

  • Klasyfikacja zdań (np. wykrywanie czy recenzja jest pozytywna czy negatywna): Dodajemy warstwę klasyfikującą nad tokenem [CLS]. Trenujemy na paru tysiącach przykładów recenzji, i BERT szybko dostosowuje się, ucząc się, że np. wektor [CLS] powinien zawierać informacje przydatne do oceny sentymentu. Po trenowaniu, BERT + ta warstwa daje predykcje etykiet.
  • Pytania i odpowiedzi (SQuAD): Dodajemy dwie warstwy liniowe nad wyjściami BERT-a, przewidujące prawdopodobieństwo, że dany token jest początkiem odp. lub końcem odp. Model dostaje paragraf + pytanie jako wejście (są rozdzielone tokenem [SEP]) i uczy się zaznaczać fragment będący odpowiedzią. BERT fine-tuned w ten sposób pobił dedykowane wcześniej systemy, bo jego reprezentacje słów w kontekście zawierają już sporo wiedzy językowej i (jak się okazało) nawet częściowo encyklopedycznej z ogromnego korpusu treningowego (Wikipedia + Books).
  • Rozwiązywanie koreferencji, rozpoznawanie encji, analizę składniową… – praktycznie dowolne zadanie językowe można sfine-tune’ować z BERT-em, zamiast trenować model od zera. To stało się standardem: od 2018 konkursy i rankingi NLP zdominowały modele z rodziny BERT (lub ulepszone).

Przykład (Python): Użyjmy BERT-a do prostego zadania – uzupełniania maski (co odpowiada treningowemu zadaniu MLM). Skorzystamy z pipeline HuggingFace fill-mask.

from transformers import pipeline
# Pipeline z modelu BERT-base uncased do uzupelniania masek
unmasker = pipeline("fill-mask", model="bert-base-uncased")
sentence = "Deep learning __ revolutionizing natural language processing."
sentence = sentence.replace("__", unmasker.tokenizer.mask_token)
for pred in unmasker(sentence):
    print(f"{pred['sequence']}  (p={pred['score']:.3f})")

W powyższym zdaniu wstawiliśmy maskę zamiast jednego słowa. BERT zaproponuje uzupełnienia, np.: “Deep learning is revolutionizing natural language processing.” (z wysokim prawdopodobieństwem) albo “Deep learning was revolutionizing …” etc. To pokazuje, że model „rozumie” kontekst gramatyczny zdania. Co więcej, BERT często podpowiada sensowne semantycznie słowa. Gdyby zdanie brzmiało np. “He went to the __ to withdraw money.”, BERT zapewne zaproponuje “bank” jako maskę, bo pasuje kontekstowo.

Inny przykład – klasyfikacja z użyciem BERT fine-tune’owanego na określone zadanie:

from transformers import AutoTokenizer, AutoModelForSequenceClassification

tokenizer = AutoTokenizer.from_pretrained("nlptown/bert-base-multilingual-uncased-sentiment")
model = AutoModelForSequenceClassification.from_pretrained("nlptown/bert-base-multilingual-uncased-sentiment")

text = "Ta książka jest naprawdę świetna!"
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)
probs = outputs.logits.softmax(dim=1)
print("Rozkład prawdopodobieństw klas:", probs.detach().numpy())

Tutaj użyliśmy gotowego modelu BERT (multilingual) przystosowanego do analizy sentymentu (zwraca 5-stopniową ocenę od 1 do 5 gwiazdek). Wektor outputs.logits to wyniki dla każdej klasy; po softmaxie możemy odczytać, że zdanie “naprawdę świetna” zapewne otrzyma najwyższe prawdopodobieństwo klasy pozytywnej (np. 5 gwiazdek). Ten przykład ilustruje, jak BERT może zostać użyty jako gotowy komponent do konkretnej aplikacji.

Wpływ BERT-a: BERT zapoczątkował erę masywnego pretrenowania modeli na niesuperwizowanych danych i fine-tuningu pod konkretne zadania. Jego sukces potwierdził hipotezę, że sieć neuronowa może nauczyć się swoistego „językowego zdrowego rozsądku” czy też wiedzy o języku, jeśli przeczyta dostatecznie dużo tekstu. BERT został wytrenowany na ~3.3 mld słów (BooksCorpus + Wikipedia) i okazało się, że w jego parametrach zakodowane są różnorakie informacje:

  • składniowe (rozpoznaje części mowy, zależności składniowe bez uczenia jawnego),
  • semantyczne (zna synonimy, hyponimy),
  • a nawet fakty (na prostsze pytania encyklopedyczne typu “Who wrote Moby Dick?” czasem BERT-large potrafił odpowiedzieć bez dodatkowej wiedzy, sugerując że wyczytał to w Wikipedii podczas pretreningu).

BERT stał się bazą dla niezliczonych wariantów i rozszerzeń: modyfikowano architekturę (RoBERTa – lepsze treningi, bez NSP; ALBERT – lżejszy BERT ze współdzieleniem wag; DistilBERT – wersja z mniejszą liczbą warstw itd.), adaptowano go do innych języków (m.in. PolBERT dla polskiego, mBERT – wersja wielojęzyczna, o czym w następnej sekcji) oraz innych modalności (VisualBERT do multimodalu tekst+obraz). Idea pretrenowania bidirectional transformer encoder zawędrowała też poza NLP (np. w biologii modele typu BERT są używane do predykcji struktury białek na podstawie sekwencji aminokwasów).

Ograniczenia: Oczywiście, BERT nie jest magiczny:

  • Maskowanie vs generowanie: BERT jest modelem masked (enkoderowym), nie generatywnym autoregresyjnym. To znaczy, świetnie radzi sobie z rozumieniem i uzupełnianiem luk, ale nie generuje tekstu od zera. Jeśli chcemy pisać eseje czy prowadzić dialog, architektura BERT się nie nada – do tego lepsze są modele pokroju GPT (dekoderowe). Dlatego w kolejnych latach uwagę przyciągnęły rozwinięcia GPT, ale również modele łączące oba światy (np. T5 – które łączy enkoder i dekoder transformera).
  • Ograniczona długość kontekstu: BERT-base miał maksymalną długość wejścia 512 tokenów. To dużo jak na zdania, ale mało np. na całe dokumenty. W zadaniach wymagających kontekstu powyżej tej granicy BERT nie pomoże bez modyfikacji.
  • Brak aktywnej pamięci/aktualizacji wiedzy: BERT po treningu jest statyczny. Wie to, co wyczytał do 2018 roku. Nie można łatwo dołączyć do niego nowej wiedzy (poza ponownym trenowaniem). Stąd badania nad aktualizacją faktów w modelach lub korzystaniem z zewnętrznych baz wiedzy. Ten temat zresztą powraca w sekcji o modelach hybrydowych.
  • Rozmiar i wymagania: BERT-large miał 340M parametrów – w 2018 to było bardzo dużo (trudno trenowalne od zera bez ogromnych zasobów). Dziś to już nie szokuje (GPT-3 ma 175 miliardów), ale mimo to duże modele są trudne do wdrożenia np. na urządzeniach mobilnych czy w aplikacjach czasu rzeczywistego bez odpowiedniej infrastruktury.

Mimo tych ograniczeń, BERT na trwałe zmienił standardy. Wraz z następnymi modelami (XLNet, GPT-2, RoBERTa) zapoczątkował „wyścig zbrojeń” w parametrach i danych. Kolejne sekcje opisują, jak w latach 2019–2021 skupiono się na powiększaniu modeli i uczynieniu ich coraz bardziej zdolnymi (np. generacja tekstu, obsługa wielu języków, wykonywanie wielu zadań jednocześnie).

5. GPT-2 (2019) – generowanie tekstu, transformery, skalowanie modeli

Kontekst: W 2018 OpenAI zaprezentowało model GPT (Generative Pre-Training) – był to „brat” BERT-a, ale działający autoregresywnie, czyli przewidujący następny token na podstawie poprzednich. GPT-1 (bo tak dziś się go nazywa) miał ~117M parametrów i pokazał, że model językowy (LM) oparty o transformera dekodera, pretrenowany na dużym korpusie (książki) i potem fine-tune’owany, daje świetne wyniki np. w odpowiedzi na pytania czy rozumieniu dialogów ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding) ([1810.04805] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding). Jednak prawdziwy przełom nastąpił z następcą – GPT-2. W lutym 2019 OpenAI ogłosiło model GPT-2 o 1,5 miliarda parametrów, wytrenowany na 8 milionach stron internetowych (korpus WebText, ok. 40 GB danych tekstowych) (Language Models are Unsupervised Multitask Learners). GPT-2 był znacznie większy niż wcześniejsze modele i po raz pierwszy zademonstrował zdolność generowania długich, spójnych fragmentów tekstu, które na pierwszy rzut oka trudno było odróżnić od tekstu napisanego przez człowieka (Language Models are Unsupervised Multitask Learners) (Language Models are Unsupervised Multitask Learners). OpenAI początkowo wstrzymało pełne wydanie modelu, powołując się na obawy o możliwe nadużycia (np. generowanie fałszywych wiadomości). Ostatecznie model upubliczniono kilka miesięcy później, co pozwoliło społeczności badać jego możliwości.

Architektura i mechanizm: GPT-2 to transformer dekoder (12 do 48 warstw, w zależności od wielkości modelu), trenowany jako klasyczny model języka – czyli przewiduje kolejny token patrząc na sekwencję dotychczasowych. Kluczowe różnice względem BERT:

  • Działa jednokierunkowo (lewostronnie) – każdy token może zobaczyć tylko tokeny przed nim (poprzedzające) w mechanizmie self-attention. To dlatego, że używamy go do generacji: generując token nr 5 nie możemy jeszcze widzieć tokenu 6, bo on nie istnieje. W BERT-cie odwrotnie – maskujemy środek i patrzymy z obu stron, ale nie generujemy nowej sekwencji.
  • Nie ma masek [MASK] w danych – model po prostu czyta dużo ciągłego tekstu i stara się go przewidzieć słowo po słowie. To uczenie samodzielne (unsupervised): nic nie etykietujemy, po prostu dajemy teksty z internetu.
  • Duża pojemność i dane: 1.5B parametrów i świetnej jakości korpus (WebText był budowany z linków z reddita z wysokim upvotem, by unikać treści niskiej jakości). To powoduje, że model ma dużo większą „wiedzę” i płynność językową niż GPT-1 (117M param).

Umiejętności GPT-2: Po treningu okazało się, że GPT-2:

  • Potrafi generować długi, spójny tekst na zadany temat. Wystarczy podać mu prompt (zaczątek tekstu), a on dopisuje ciąg dalszy. Często zaskakująco logiczny w kilku pierwszych akapitach.
  • Wykazuje zdolność do zero-shot learning na pewnych zadaniach. W raporcie OpenAI pokazano, że GPT-2 radzi sobie bez trenowania na zadaniach takich jak tłumaczenie z francuskiego na angielski czy odpowiadanie na pytania – jeśli sformułujemy input odpowiednio jako polecenie (prompt) (Language Models are Unsupervised Multitask Learners) (Language Models are Unsupervised Multitask Learners). Np. podając „Translate to English: Je suis étudiant. =>” model wygenerował „I am a student.” mimo że nie trenowano go bezpośrednio na parze tłumaczeniowej. To dlatego GPT-2 podczas czytania internetu prawdopodobnie widział wiele zdań w różnych językach i ich tłumaczeń, Q&A itp., i jest w stanie uogólnić. OpenAI określiło to w publikacji hasłem: „Language models are unsupervised multitask learners” – duży model językowy potrafi zaskakująco wiele bez dodatkowego uczenia (Language Models are Unsupervised Multitask Learners) (Language Models are Unsupervised Multitask Learners).
  • Osiągał nowe SOTA w modelowaniu języka (perpleksja) na różnych zbiorach, przewyższając poprzednie modele – co dowodziło, że skalowanie modelu i danych poprawia wynik log-liniowo (wykresy w pracy pokazały niemal liniową poprawę log(perplexity) w funkcji log(rozmiaru modelu)) (Language Models are Unsupervised Multitask Learners) (Language Models are Unsupervised Multitask Learners).
  • GPT-2 generował również błędne lub fantastyczne odpowiedzi – jego model świata jest statystyczny, nie zawsze zgodny z faktami. Ale stylistycznie bywał przekonujący, co rodziło obawy (tzw. problem halucynacji modelu).

Przykład (Python): Wygenerujmy tekst za pomocą GPT-2 (dostępnego w HuggingFace). Użyjemy pipeline text-generation:

from transformers import pipeline
generator = pipeline("text-generation", model="gpt2")
prompt = "Machine learning can be defined as"
result = generator(prompt, max_length=50, num_return_sequences=1)
print(result[0]['generated_text'])

Ten kod da np. wynik: “Machine learning can be defined as a field of computer science that uses statistical techniques to give computer systems the ability to learn from data, without being explicitly programmed. This definition… ” (model prawdopodobnie popisze się definicją podobną do Wikipedii). Oczywiście wyniki mogą się różnić – generacja jest stochastyczna. Ale sens pozostanie: GPT-2 umie kontynuować myśl w stylu naukowym.

Inny przykład: generacja prozy:

prompt = "Once upon a time, in a distant galaxy,"
print(generator(prompt, max_length=60, num_return_sequences=1)[0]['generated_text'])

Moglibyśmy dostać coś w stylu: “Once upon a time, in a distant galaxy, there lived a young princess who dreamed of exploring the stars. Every night she would gaze at the twinkling sky, wondering what secrets lay beyond her planet. One day, an ancient map fell into her hands, revealing…” – model potrafi kontynuować narrację wymyślając dalszy ciąg.

Zastosowania GPT-2: Model szybko znalazł zastosowanie wszędzie tam, gdzie trzeba generować tekst:

  • Autouzupełnianie, asystenci pisania: np. podpowiedzi zdań w edytorach, generowanie sugestii odpowiedzi (smart reply).
  • Chatboty konwersacyjne: wczesne prototypy „sztucznej inteligencji” konwersującej z człowiekiem budowano już na GPT-2 (choć GPT-2 nie był specjalnie uczuony do dialogu, radził sobie zaskakująco nieźle po dostrojeniu).
  • Generatory treści: od opisów produktów, przez twórcze pisanie (scenariusze, opowiadania) po memy internetowe – ludzie eksperymentowali, jak model może asystować lub automatyzować tworzenie tekstów.
  • Ewentualnie zadania analityczne: GPT-2 jako model językowy można też fine-tune’ować do klasyfikacji, analizy sentimentu itp., choć do takich zadań częściej brano BERT-a. GPT-2 jednak bywa używany np. do generowania możliwości odpowiedzi, które potem są sprawdzane.

Ograniczenia: GPT-2, pomimo imponujących wyników, ma wiele ograniczeń:

  • Brak kontroli i faktów: Model potrafi halucynować – generować przekonująco brzmiące, ale nieprawdziwe informacje. Nie jest podłączony do żadnej bazy wiedzy ani weryfikacji faktów.
  • Ciężko sterować formatem odpowiedzi: Trzeba odpowiednio inżynierować prompt, by otrzymać pożądany rezultat. Np. by wymusić pewien styl albo uzyskać konkretną informację, user musi eksperymentować z wejściem (stąd rozkwit „prompt engineering”). GPT-2 nie miał mechanizmu instrukcji czy systemu.
  • Kontext window limit: Kontekst 1024 tokenów ogranicza długość generacji i to, do jakiego kontekstu model się odnosi. Nie przeczyta całej powieści naraz – co najwyżej stronę tekstu.
  • Bias i toksyczność: Jak wszystkie modele na danych internetowych, GPT-2 przejął pewne uprzedzenia i wulgarność z tych danych. Bez filtrów może generować niepożądane treści. OpenAI wykonało pewne filtrowanie (usunięto np. treści stricte pornograficzne z WebText), ale nie wyeliminuje to wszystkich problemów (np. stereotypów czy slangu nienawiści).
  • Brak użytkowego interfejsu: GPT-2 to surowy model. By zbudować np. chatbota, trzeba nad nim sporo pracy – m.in. ustalić, jak utrzymywać historię dialogu w promptach, jak unikać powtarzania mantry, jak reagować na pewne tematy itp. To dopiero w kolejnych generacjach (GPT-3, ChatGPT) opanowano lepiej poprzez techniki takie jak fine-tuning instrukcyjny i RLHF.

Wpływ: GPT-2 udowodnił, że skalowanie działa – większy model + więcej danych = nowe jakościowo zdolności (jak zero-shot multitasking) (Language Models are Unsupervised Multitask Learners) (Language Models are Unsupervised Multitask Learners). To zachęciło badaczy do pójścia dalej tą drogą. W 2020 pojawiły się open-source’owe repliki (GPT-Neo od EleutherAI), a OpenAI sama zajęła się budową megamodelu GPT-3 (2020) – opisanego w dalszej części. Jednocześnie społeczność zaczęła dostrzegać wyzwania: jak kontrolować takie modele, jak oceniać prawdziwość i sens generowanych treści? W ślad za GPT-2 pojawiły się prace nad wykrywaczami tekstu generowanego i nad ulepszaniem jakości (np. metodą top-k sampling, top-p nucleus sampling do bardziej sensownego doboru słów niż czysto losowe próbkowanie z modelu).

Podsumowując, GPT-2 to kamień milowy pokazujący, że generowanie języka naturalnego przez SI osiągnęło poziom użyteczności. Stał się też pewnym symbolem dylematów etycznych (czy udostępniać model mogący generować “fake news”?), co potem zaowocowało bardziej odpowiedzialnym podejściem do publikacji (np. GPT-3 został udostępniony początkowo tylko poprzez kontrolowane API).

6. Modele wielojęzyczne (2020) – mBERT, XLM-R i uniwersalne reprezentacje wielojęzyczne

Kontekst: Większość opisanych dotąd modeli pretrenowano głównie na języku angielskim (ew. chińskim). Pojawiło się jednak pytanie: czy można nauczyć jeden model obsługi wielu języków jednocześnie? Już BERT doczekał się wersji wielojęzycznej – mBERT (multilingual BERT) wydanej przez Google w 2018. mBERT to ten sam architektonicznie BERT-base, ale trenujący na Wikipedii w 104 językach (łącznie). Co ciekawe, mBERT nie używał specjalnie oznaczonych informacji o języku – po prostu tokenizował teksty z różnych języków (wspólnym słownikiem opartym o WordPiece) i uczył maskować tokeny. Ku pewnemu zaskoczeniu, model ten nauczył się wspólnej, uniwersalnej przestrzeni reprezentacji – tzn. np. słowo “kot” i “cat” (PL vs EN) miały częściowo zbieżne wektory kontekstowe, jeśli występowały w podobnych zdaniach ([1911.02116] Unsupervised Cross-lingual Representation Learning at Scale). mBERT miał ograniczenia (np. słabo radził sobie dla języków bardzo odmiennych czy rzadkich, a także dla par języków o różnych alfabetach), ale pokazał potencjał: posiadanie jednego modelu dla wielu języków pozwala transferować wiedzę z języków bogatych w dane (np. angielski) na języki ubogie (np. suahili).

Rok 2019–2020 przyniósł dalsze prace: Facebook AI wypuścił XLM i XLM-R:

Mechanika modeli wielojęzycznych: W praktyce, modele typu mBERT/XLM mają wspólny słownik subwordów obejmujący różne języki. Przykładowo subword “mus” może pojawiać się w angielskim (music) jak i polskim (muzyka), więc model uczy się jednej reprezentacji tego ciągu liter, co może spiąć semantykę. Dla różnych alfabetów (np. chińskiego, arabskiego, łacinki) są oddzielne pule subtokenów. Mimo to model potrafi część koncepcji uogólnić – np. koncept liczby mnogiej, składni zdania oznajmującego vs pytania, itp., co jest wspólne między językami, zostaje zapisany w parametrach. Powstaje coś w rodzaju uniwersalnej reprezentacji znaczeń, z której da się odtworzyć różne języki. Ciekawym zjawiskiem jest, że model wielojęzyczny potrafi np. na wejściu zdanie polskie, na wyjściu (po warstwach) otrzymać wektory, które są bardzo bliskie wektorom wyjściowym dla odpowiadającego zdania angielskiego. To tłumaczy, czemu np. mBERT trenowany tylko jako model językowy potrafił rozwiązywać zadania cross-lingual: trenowano go np. by rozpoznawał nazwane entycje na angielskim (fine-tuning), a testowano na hiszpańskim – i działał, bo “London” i “Londres” miały podobne reprezentacje, więc classifier entycji zadziałał na obu.

Zastosowania praktyczne:

  • Głównym atutem modeli wielojęzycznych jest transfer learning między językami. Jeśli mamy mało danych anotowanych np. dla języka X, można wytrenować model wielojęzyczny na danych angielskich (których jest obficie), a potem użyć go na języku X. To dramatycznie poprawiło dostępność dobrych modeli dla języków mniejszych. Np. klasyfikator zamiarów klienta w call center można trenować po angielsku i zastosować (z drobnymi poprawkami) dla wielu innych języków, zamiast trenować osobno każdy od zera.
  • Systemy wielojęzyczne: Wyszukiwarka, która z pytania w dowolnym języku potrafi znaleźć odpowiedź w dokumencie w innym języku (cross-lingual retrieval), lub czatbot obsługujący wielu języków jedną architekturą.
  • Szybszy rozwój modeli dla języków niskozasobowych: Zamiast czekać, aż ktoś zbierze gigantyczny korpus np. w suahili do trenowania transformera od zera, można użyć wspólnego modelu (jak XLM-R) i fine-tune na skromnym korpusie suahili, ufając, że model ma już zakodowaną sporo wiedzy lingwistycznej z pokrewnych języków.

Przykład (Python): Pokażmy, jak użyć XLM-R do wyznaczania reprezentacji zdań w różnych językach i porównać ich podobieństwo.

from transformers import AutoTokenizer, AutoModel
import torch
tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base")
model = AutoModel.from_pretrained("xlm-roberta-base")

sentences = ["Koty są wspaniałe zwierzęta.",  # polski
             "Cats are wonderful animals.",   # angielski
             "Les chats sont des animaux merveilleux."]  # francuski
# Tokenizacja i inferencja
inputs = tokenizer(sentences, padding=True, return_tensors="pt")
outputs = model(**inputs)  # wyjścia modelu
# Weźmy wektor [CLS] (w XLM-R jest to token <s> na początku)
cls_indices = [0, len(outputs.last_hidden_state[1]) - 1, len(outputs.last_hidden_state[2]) - 1]
embeddings = outputs.last_hidden_state[range(len(sentences)), cls_indices, :]
# Obliczmy kosinusowe podobieństwo między embeddingami zdań
cos = nn.CosineSimilarity(dim=1)
sim_pl_en = cos(embeddings[0].unsqueeze(0), embeddings[1].unsqueeze(0))
sim_pl_fr = cos(embeddings[0].unsqueeze(0), embeddings[2].unsqueeze(0))
print("Podobieństwo zdanie PL vs EN:", float(sim_pl_en))
print("Podobieństwo zdanie PL vs FR:", float(sim_pl_fr))

Jeśli model rzeczywiście reprezentuje znaczenia podobnie, zdanie polskie “Koty są wspaniałe zwierzęta.” powinno mieć wysoki kosinus z angielskim odpowiednikiem “Cats are wonderful animals.” (blisko 1), a także z francuskim tłumaczeniem. Gdybyśmy porównali do zdania o innej treści, podobieństwo byłoby niższe.

Ograniczenia modeli wielojęzycznych:

  • Pojemność vs liczba języków: Choć XLM-R pokazuje, że dodanie parametrów pozwala objąć 100 języków, to jednak w praktyce bardzo wielojęzyczne modele są ogromne. Niełatwo je trenować i trzymać. Pojawiają się też efekty dilution dla skrajnie wielu języków – np. model uczący się 300 języków może nadal nie przyswoić dobrze tych najrzadszych.
  • Brak kontroli języka w generacji: W modelach generatywnych wielojęzycznych (jak mGPT czy mBART) może być problem: model czasem miesza języki lub przełącza się (tzw. code-switching), jeśli nie jest mocno ukierunkowany. Np. prosząc o wygenerowanie tekstu po hiszpańsku, model może wtrącić angielskie słowo, jeśli było częste w treningu. To widać nawet w mBERT – Bahdanau ponoć żartował: „mBERT is a mouthful of 100 languages, but knows none perfectly” – model trochę gubi finezje poszczególnych języków. Badania nad kontrolą języka (np. przez podawanie specjalnego tokena [LANG]) są prowadzone.
  • Braki danych: Są języki tak egzotyczne lub z małą ilością cyfrowego tekstu, że nawet duże modele wielojęzyczne niewiele im pomogą. Np. języki rdzenne Ameryk, wiele dialektów afrykańskich – tu problemem jest brak corpora do pretreningu. Istnieją inicjatywy typu mT5 (540 mld param, 101 języków) czy BLOOM (176 mld param, 59 języków) – te starają się objąć szerzej świat językowy.
  • Kwestie kulturowe i poprawność: Model wytrenowany na dziesiątkach języków może odziedziczyć biases z wielu kultur jednocześnie. To trudne do oceny i korygowania, bo potrzeba wielojęzycznej wiedzy.

Podsumowując, modele wielojęzyczne to ogromny krok ku demokratyzacji NLP – nie tylko giganci jak angielski, ale też polski, hiszpański, hindi czy suahili mogą korzystać ze zdobyczy transformatorów. W praktyce biblioteki (jak Transformers) pozwalają dziś łatwo użyć takich modeli: np. pipeline z modelu bert-base-multilingual-cased da nam klasyfikator działający na wejściach polskich, arabskich, rosyjskich itd., jeśli tylko został dostrojony. Dzięki temu firmy i badacze mogą budować systemy wielojęzyczne bez potrzeby posiadania osobnego modelu per język.

7. T5 (2020) – koncepcja “tekst-za-tekst”, ujednolicenie zadań NLP

Kontekst: W 2020 obserwowaliśmy pewien rozkwit różnych modeli pretrenowanych: BERT-y do zadań rozumienia, GPT do generacji, dedykowane architektury do tłumaczeń (Transformer, Marian), inne do Q&A. Pojawiło się pytanie: czy da się to ujednolicić? Czy jeden uniwersalny model może zostać wstępnie wytrenowany tak, by potem po minimalnym dostrojeniu umieć wykonywać każde zadanie językowe – od klasyfikacji po tłumaczenie i generację? Odpowiedzią Google Research był model T5 (Text-To-Text Transfer Transformer), opisany w pracy „Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer” ([1910.10683] Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer). T5 zaproponował ramy tekst-za-tekst – wszystko, co chcesz z nim zrobić, musisz sformułować jako zadanie polegające na przekształceniu tekstu wejściowego w tekst wyjściowy ([1910.10683] Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer).

Jak to działa? Przykłady:

  • Klasyfikacja zdań: wejście: „sst2 sentence: X” (gdzie sst2 to nazwa zadania – tu sentiment analysis), wyjście: „positive” albo „negative”. Zamiast liczby czy etykiety, model generuje słowo “positive”. Tekst na wejściu, tekst na wyjściu.
  • Tłumaczenie: wejście: „translate English to German: This is a cat.”, wyjście: „Dies ist eine Katze.”. Czyli znowu ciąg tekstowy w ciąg tekstowy, tylko inny język.
  • Streszczenie: wejście: „summarize: [artykul]”, wyjście: streszczenie zdaniowe.
  • QA: wejście: „question: Pytanie context: Dokument”, wyjście: „Odpowiedź”.

Dzięki temu architektura modelu jest jedna – to po prostu Transformer Encoder-Decoder (tak jak klasyczny Transformer do tłumaczeń). T5 jest pretrenowany na wielkim korpusie (C4 – 750 GB czystego tekstu webowego (Exploring Transfer Learning with T5: the Text-To … - Google Research)) za pomocą zadań polegających na rekonstruowaniu tekstu. Główny pretrainingowy objective T5 to wariant maskowania: tzw. span-corruption – losowo wybierane fragmenty tekstu (ciągi kilku słów) są usuwane i zastąpione jednym tokenem sentinelowym, a model ma wygenerować te brakujące fragmenty rozdzielając je tymi sentinelami. To ogólna forma MLM (łatwiej modelowi uczyć się generować kilka słów jednocześnie). Po takiej nauce (w stylu autoenkodera) T5 jest dostrajany pod zadania – ale zadania też są podane w formie tekst-to-text.

Kluczowe spostrzeżenie autorów: ujednolicenie formatu pozwala wspólnie trenować model na wielu zadaniach i przenosić wiedzę między zadaniami ([1910.10683] Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer). Np. model trenuje się jednocześnie na tłumaczeniach i na czytaniu ze zrozumieniem, co może poprawić jego ogólną wiedzę językową i światową, a architektura jest wspólna. T5 osiągnął SOTA na wielu benchmarkach i był jednym z pierwszych modeli, który jednocześnie był dobry i w generacji (np. tłumaczenie) i w rozumieniu (np. GLUE) ([1910.10683] Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer).

Google wypuściło T5 w różnych rozmiarach: od T5-Small (~60M parametrów) po T5-XXL (11 miliardów). Co ciekawe, nawet te mniejsze wersje były całkiem skuteczne w transferze – co dowodzi, że dobrze dobrany pre-training plus multi-task potrafi zdziałać wiele bez konieczności ekstremalnego powiększania parametru (choć T5-XXL oczywiście był najlepszy kosztem ogromnych wymagań).

Przykład (Python): Zilustrujmy użycie T5 do różnych zadań z wykorzystaniem transformera T5-base. Zademonstrujemy tłumaczenie i streszczenie.

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

tokenizer = AutoTokenizer.from_pretrained("t5-base")
model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")

# Zadanie: tłumaczenie EN->DE
input_text = "translate English to German: I like programming."
inputs = tokenizer(input_text, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=10)
translation = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Translation:", translation)

# Zadanie: streszczenie
article = "summarize: Deep learning has revolutionized NLP by enabling models to learn representations and tasks from large data..."
inputs = tokenizer(article, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=20)
summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("Summary:", summary)

Ten kod pokazuje, że ten sam model t5-base potrafi zarówno tłumaczyć, jak i streszczać – kluczem jest właściwie sformułowany prompt (prefiks zadania). Dla tłumaczenia dostaniemy np. „Ich mag Programmieren.”, a dla streszczenia model wygeneruje krótkie podsumowanie (np. „Deep learning transformed NLP by allowing models to learn from big data.”). W porównaniu do GPT-2, T5 wie, kiedy przestać (generuje <EOS> logicznie po zakończeniu streszczenia) i trzyma się bardziej kluczowych informacji (bo był trenowany także do streszczania).

Zastosowania: T5 w praktyce bywa wykorzystywany w multi-task systems. Np. asystent, który jednocześnie może przetłumaczyć coś, odpowiedzieć na pytanie lub streścić tekst, mając jedną uniwersalną architekturę backendową. Także w badaniach nad „task-based prompting” – T5 jest dobrym poligonem do testów, jak model radzi sobie z kombinacjami zadań. Wersje T5 pojawiły się dla innych języków (mT5 dla wielu jęz., byt5 dla języka polskiego itp.).

Ograniczenia:

  • Mimo uniwersalności, T5 to nadal model wymagający fine-tune’u dla konkretnego zestawu zadań. Wprawdzie pokazano, że multi-task fine-tuning na wielu zadaniach naraz działa nieźle, ale wciąż żeby dodać nowe zadanie, trzeba go douczyć.
  • Format text-to-text czasem bywa nieintuicyjny dla pewnych problemów. Np. zadania detekcji (np. czy zdanie zawiera błąd gramatyczny – w klasyfikacji wyplułby binarną etykietę, a w T5 musi wygenerować np. “true”/“false”). To drobiazg, ale wymaga standaryzacji outputów.
  • T5 ma architekturę enkoder-dekoder, co jest super do zadań wejście->wyjście, ale np. do samych klasyfikacji można by chcieć użyć tylko enkodera (mniej obliczeń). Tutaj decydujemy się na uniwersalność kosztem optymalności dla pewnych przypadków.
  • Podczas generacji T5 bywał nieco mniej płynny niż GPT-2 (według anegdot). To może wynikać z tego, że T5 “nauczył się lakoniczności” – bo w multi-task uczyli go generować bardzo zwięźle np. w QA (tylko konkretną odpowiedź) lub w streszczeniach. GPT-2, trenowany czysto językowo, był gadatliwy. W pewnych zastosowaniach to plus, w innych minus.
  • Podobnie jak inne modele, T5 jest ograniczony długością kontekstu (512 tokenów train, można podbić do ~1024 przy generacji, ale nie więcej bez modyfikacji).

Wpływ: T5 pokazał drogę do uniwersalnych frameworków i zainspirował wiele następnych prac. OpenAI później zaproponowało np. FLAN – fine-tuning instructional (uczenie modeli by rozwiązywały zadania na podstawie instrukcji w jęz. naturalnym, co jest wariantem multi-task, gdzie każde zadanie opisuje się promptem). T5 wskazał, że spójny interfejs tekstowy ułatwia modelowi generalizację – co jest w pewnym sensie prorocze dla pojawienia się ChatGPT: tam też mamy interfejs językowy (polecenia), a model radzi sobie z różnymi funkcjami.

Podsumowując: T5 to szwajcarski scyzoryk NLP – jedna architektura, jedno formatowanie, wiele możliwości. Dla programistów to cenna idea: zamiast budować oddzielnie pipeline do tłumaczenia, pipeline do klasyfikacji itp., możemy mieć jeden model i zarządzać nim poprzez prompty określające zadanie. W praktyce biblioteka Transformers daje gotowe modele T5 fine-tuned np. do konkretnych celów (np. t5-small-wmt-en-de do tłumaczenia, t5-base-qg do generowania pytań z tekstu itp.), ale można też samemu fine-tune pod własny zestaw tasków.

8. GPT-3 (2021) – skalowanie do 175 mld parametrów, zero-shot i few-shot learning

Kontekst: GPT-2 pokazał moc skalowania do 1.5B, więc kolejne logiczne pytanie brzmiało: co jeśli pójdziemy 100x większe? W 2020 OpenAI zbudowało GPT-3 – model z 175 miliardami parametrów, wytrenowany na około 500 miliardach tokenów (mieszanka internetu, książek, Wikipedii). Wyniki opublikowano w 2020 (Brown et al., „Language Models are Few-Shot Learners” na NeurIPS 2020) ([2005.14165] Language Models are Few-Shot Learners). GPT-3 stał się słynny z dwóch powodów:

  • Był (na tamten czas) największym i najpotężniejszym modelem językowym w historii, demonstrującym zaskakujące umiejętności.
  • Spopularyzował termin “few-shot learning” bez trenowania – model potrafił dostosować się do nowych zadań po przeczytaniu zaledwie kilku przykładów, w ramach samego promptu, bez modyfikacji wag ([2005.14165] Language Models are Few-Shot Learners). To tak, jakby model “na bieżąco” uczył się z promptu. Np. jeśli chcemy, by GPT-3 napisał wiersz, wystarczy pokazać mu dwa przykładowe wiersze i poprosić o trzeci. W wielu przypadkach potrafił to zrobić z imponującą sprawnością.

Architektura i trening: GPT-3 to bez zmian architektura Transformer Decoder (taka jak GPT-2, tylko głębsza i szersza). Kluczem jest skala: 96 warstw, wektor ukryty 12288-D, 96 głów uwagi. Trening trwał na tysiącach GPU. Nie zastosowano przy tym żadnych nowinek architektonicznych – postawiono na czyste skalowanie i dobrą inżynierię (stabilność FP16, zarządzanie pamięcią, itd.). Po treningu model nie był fine-tune’owany na żadne zadanie konkretnie. Zamiast tego autorzy przetestowali go w trybach:

  • Zero-shot: model dostaje polecenie/pytanie i od razu generuje odpowiedź (np. prompt: “Q: How many eyes does a horse have? A:” -> model generuje “Two.”). Zaskakująco, GPT-3 robił to często poprawnie.

  • One-shot, few-shot: do promptu dodajemy 1 lub kilka przykładów w formie demonstracji. Np.

    Translate English to Spanish:
    English: I like cats.
    Spanish: Me gustan los gatos.
    
    English: Do you speak Spanish?
    Spanish:

    i GPT-3 uzupełnia “¿Hablas español?”. W badaniach Brown et al. pokazali, że GPT-3 często osiąga wyniki zbliżone do modeli specjalizowanych właśnie dzięki takiemu podpowiedzeniu kontekstu ([2005.14165] Language Models are Few-Shot Learners). W tłumaczeniu, odpowiadaniu na pytania, rozumowaniu arytmetycznym itp., GPT-3 z kilkoma przykładami w prompt potrafił przebić wiele poprzednich SOTA, choć nadal bywał gorszy od modeli trenowanych nadzorowanie na te zadania.

To zjawisko nazwali in-context learning – model uczy się kontekstowo od użytkownika, zamiast gradient descentem. Nie do końca “uczy” w sensie zmiany wag, ale jego wewnętrzna zdolność uogólniania jest tak mocna, że przykłady w kontekście traktuje niczym dane treningowe, tyle że jednorazowe. To jakby GPT-3 potrafił symulować proces fine-tuningu w obrębie jednego forward passa.

Umiejętności GPT-3: Poza zadaniami czysto językowymi, GPT-3 wykazywał też kreatywność i pewne rozumowanie:

  • Generował kawałki kodu (był w stanie pisać proste programy w Pythonie, HTML, SQL – bo w corpusu widział dużo kodu).
  • Rozwiązywał proste zadania matematyczne czy logiczne, np. arytmetyka 2-3 cyfrowa, prosty wnioskowanie (choć na tym polu nie był niezawodny) ([2005.14165] Language Models are Few-Shot Learners).
  • Pisał wiersze, żarty, symulował dialogi z różnymi stylami (np. jako postać z filmu).
  • Miał w pamięci masę wiedzy encyklopedycznej i faktów (jak model 100x większy niż BERT, to i wiedzy więcej; choć nie zawsze pewnie dostępnej).
  • Radził sobie z nietypowymi formatami: np. uzupełnianie tabel, list punktowanych, transliteracja, formatowanie dat – bo w treningu widział bardzo różnorodne dane z internetu.

Przykład (pseudo kod API): GPT-3 nie jest open-source, ale OpenAI udostępnia go przez API. Kod użycia wygląda np. tak (Python, z pakietem openai):

import openai
openai.api_key = "SK-..."  # klucz do API OpenAI
prompt = (
    "Question: Who wrote the novel '1984'?\n"
    "Answer:"
)
response = openai.Completion.create(
  engine="text-davinci-003",  # variant GPT-3
  prompt=prompt,
  max_tokens=10,
  temperature=0  # deterministycznie
)
print(response.choices[0].text.strip())

Po wysłaniu zapytania do API, dostalibyśmy odpowiedź: “George Orwell”. W powyższym przykładzie GPT-3 zadziałał zero-shot (tylko pytanie bez kontekstu). Można by też doprecyzować styl, dodając np. \nExplain the answer. a model pewnie dodałby parę zdań wyjaśnienia.

Zastosowania GPT-3: Ze względu na szerokie możliwości, GPT-3 (udostępniony komercyjnie w 2021) znalazł dziesiątki zastosowań:

  • Asystenci pisania i kreatywne narzędzia: generowanie akapitów tekstu, pomoc w pisaniu maili, streszczanie dokumentów, przeformułowanie zdań, tłumaczenie na inne języki lub ton wypowiedzi (np. z formalnego na potoczny).
  • Chatboty i QA: choć GPT-3 nie był jeszcze strojony jako chatbot, wiele firm próbowało go użyć jako bota do obsługi klienta lub do wewnętrznego Q&A na bazie dokumentów (poprzez prompt z dołączoną bazą wiedzy).
  • Generowanie kodu: GPT-3 stał za produktami typu GitHub Copilot (co prawda Copilot używa nieco innego modelu Codex, ale to wariant GPT-3 trenowany specjalnie na kodzie). Wielu programistów zaczęło używać GPT-3 do generowania fragmentów kodu czy wyjaśnień do kodu.
  • Badania kognitywne: GPT-3 stał się obiektem badań – testowano, czy rozumie dowcipy, czy ulega złudzeniom poznawczym, czy ma teorię umysłu. Wyniki były zaskakujące – np. potrafił rozwiązać wiele zadań z testów IQ na analogie czy wzory słowne (choć często na granicy fartu).
  • Nowe aplikacje NLP bez trenowania modelu od zera: Ludzie budowali małe prototypy np. generatorów opowiadań na podstawie kilku słów, narzędzia do konwersji notatek w listy rzeczy do zrobienia, itd. – wszystko to jedynie odpowiednio promptując GPT-3.

Ograniczenia GPT-3: Mimo imponujących zdolności, GPT-3 wciąż borykał się z problemami:

  • Halucynacje i błędy rozumowania: GPT-3 nadal często „zmyślał”. Mógł brzmieć pewnie, ale odpowiedzieć kompletnie źle. W zadaniach arytmetycznych dla większych liczb mylił się (nie ma modułu wykonującego precyzyjnie obliczenia, operuje statystycznie). Mógł produkować pseudologiczną paplaninę, gdy zadanie wymagało ścisłego wnioskowania krok po kroku.
  • Brak prawdziwego wieloetapowego wnioskowania: Chociaż GPT-3 umiał proste “on-the-fly reasoning” ([2005.14165] Language Models are Few-Shot Learners) (np. unscramble word, czyli przestawić litery by utworzyć wyraz – to robił, bo widział anagramy w treningu), to nie był w stanie planować kilku kroków naprzód świadomie. Nie miał mechanizmu pamięci roboczej czy wzorca rozumowania. Temat jak zmusić takie modele do lepszego rozumowania doprowadził do technik jak Chain-of-Thought prompting (2022) – gdzie inżynierią promptu proszono model, by najpierw wypisał swój tok rozumowania. GPT-3 z pewnym wsparciem (i poprawkami) potrafił wtedy więcej, ale wciąż często popełniał błędy logiczne.
  • Gigantyczny rozmiar: 175 mld parametrów to ogromny model – nie do uruchomienia na zwykłych urządzeniach. Dostęp był tylko przez chmurę OpenAI. To budziło też krytykę, że taka technologia jest scentralizowana i niedostępna do samodzielnego eksperymentu (co zainspirowało ruch open-source w kolejnych latach, np. model Bloom 176B czy OPT-175B od Meta, udostępnione do badawczej społeczności).
  • Koszt generacji i latencja: Każde zapytanie do GPT-3 to spore zużycie mocy obliczeniowej. Dla zastosowań interaktywnych trzeba było optymalizować (np. używać mniejszych modeli jak Curie 6.7B lub babbage 2.7B tam, gdzie wystarczały).
  • Kontrola i dopasowanie do użytkownika: GPT-3, działając zero-shot, bywał nieprzewidywalny w stylu. Czasem odpowiadał zbyt lakonicznie, czasem zbyt rozwlekle, bywał niegrzeczny jeśli prompt tego nie regulował. OpenAI wprowadziło co prawda pewne reguły (Content Filter), ale brakowało mechanizmu fine-tuning pod instrukcje użytkownika i uprzejmość. To przyszło dopiero wraz z InstructGPT (2022) i ChatGPT (które są właśnie fine-tuned GPT-3.5 modele z RLHF, uczynione bardziej posłusznymi poleceniom).

Wpływ GPT-3: Podsumowując, GPT-3 utwierdził przekonanie, że wystarczająco duży model językowy staje się uniwersalnym rozwiązywaczem zadań tekstowych ([2005.14165] Language Models are Few-Shot Learners). Po publikacji GPT-3, wiele firm i instytucji ruszyło rozwijać własne wielkie LMy:

  • AI21 wypuściło Jurassic-1 (178B),
  • NVIDIA we współpracy z Microsoftem zrobiła Megatron-Turing NLG (530B),
  • Google pracowało nad serią PaLM (540B) i LaMDA (137B, ukierunkowany na dialog) itd. Trend był jasny: parametry rosły wykładniczo. Choć dziś wiemy, że nie tylko parametry się liczą (równie ważna jest architektura, jakość danych, i sprytne techniki fine-tuningu), to lekcja z GPT-3 była taka: skalowanie nie wyczerpało się – duży model nadal generalizuje lepiej.

Dla programistów pojawiło się też nowe podejście: prompt engineering jako sposób “programowania” takiego modelu. Zamiast pisać kod, który implementuje logikę, można poprosić GPT-3 by tę logikę sam wykonał, opisując mu zadanie w języku naturalnym. To zmiana paradygmatu – model staje się swego rodzaju uniwersalną maszyną Turinga, którą “programujemy słowami” (a raczej przykładami). Stąd popularne powiedzenie „The hottest new programming language is English”. Oczywiście, to wymagało obycia i zrozumienia ograniczeń (bo model może zawieść). Ale dało ogromną elastyczność – bez trenowania nowej sieci można było spróbować model zastosować do czegokolwiek, o czym pomyślał użytkownik.

9. Modele hybrydowe (2022) – integracja metod symbolicznych i uczenia głębokiego

Kontekst: Mimo sukcesów modeli end-to-end (głębokich), wciąż obserwowaliśmy pewne ich braki – np. w rozumowaniu logicznym, wykorzystywaniu wiedzy czy interpretowalności decyzji. W tym samym czasie klasyczne systemy symboliczne (oparte np. na regułach, logice, bazach wiedzy) oferowały mocne strony: potrafiły wykonywać dokładne wnioskowanie, dysponowały jawnie zakodowaną wiedzą (np. ontologie, grafy wiedzy) i były łatwiejsze do interpretacji i kontrolowania. Jednak systemy symboliczne same nie mają zdolności uczenia się wzorców z nieuporządkowanych danych jak tekst.

Stąd idea połączenia uczenia głębokiego z metodami symbolicznymi, czyli Neuro-Symbolic AI. Nie jest ona nowa – sięga korzeniami lat 80., a i wokół 2017-2018 zaczęły się pojawiać publikacje o łączeniu sieci neuronowych z logiką. Ale około 2022 nastąpił wzrost zainteresowania praktycznymi hybrydami w NLP. Modele hybrydowe starają się wykorzystać najlepsze cechy obu światów:

  • Komponenty uczące się (neuronowe) dostarczają rozumienia danych nieustrukturyzowanych (tekstu, mowy, obrazów), wyłapują miękkie wzorce, reprezentują znaczenia w sposób ciągły.
  • Komponenty symboliczne zapewniają twarde rozumowanie, korzystają z jawnej wiedzy i reguł, mogą też narzucać modelowi pewne ograniczenia (np. spójność logiczną).

Przykłady podejść hybrydowych w NLP:

  • Wykorzystanie wiedzy zewnętrznej w LLM: Np. systemy Retrieval-Augmented Generation (RAG), gdzie model językowy (np. GPT) podczas generowania może wyszukiwać informacje w bazie dokumentów (np. wektorową wyszukiwarką) i włączać je do odpowiedzi. Symboliczne tu jest samo wyszukiwanie i baza wiedzy – jest niezależna i jawna. Model uczy się tylko korzystać z niej (poprzez mechanizm atencjonowania podanego kontekstu). To zapobiega halucynacjom i uaktualnia wiedzę bez przebudowy modelu.
  • Logika i ograniczenia: Np. Neural Theorem Provers – modele, które łączą sieci neuronowe do oszacowania prawdopodobieństw faktów z modułem logicznego dowodzenia (np. ILP – Inductive Logic Programming). Albo Constraints satisfaction with neural guidance – model generuje rozwiązanie, ale jest sprawdzane symbolicznie pod kątem spełniania reguł, a w razie sprzeczności korygowane.
  • Parsers i gramatyki neuronowo-symboliczne: Np. wykorzystanie formalnej gramatyki do zapewnienia, że wygenerowany tekst/kod jest poprawny składniowo, przy jednoczesnym użyciu modelu neuronowego do generowania treści. Przykład: model generuje program w Pythonie, ale dodatkowo trzyma się reguł składni – można to osiągnąć integrując parser (lub maskując tokeny niedozwolone w danym kontekście).
  • Symboliczne narzędzia w łańcuchu myślenia: Pewien nurt (szczególnie 2022/2023) to wyposażać LLM w możliwość wywoływania narzędzi, np. kalkulatora, systemu algebraicznego, czy przeglądarki. Kiedy model „myśli” (np. w chain-of-thought), może dojść do kroku „oblicz 42*37” i wówczas zamiast sam zgadywać, wykonuje zapytanie do kalkulatora (co gwarantuje poprawny wynik). Narzędzie to komponent deterministyczny, symboliczny, a model uczy się kiedy i jak go użyć.
  • Użycie wiedzy symbolicznej do uczenia modelu: Przykładowo, korzystanie z istniejących baz wiedzy (WordNet, ConceptNet, DBpedia) by generować dodatkowe dane uczące lub dodatkowe funkcje kosztu, zmuszające model do nauki pewnych relacji. Np. dodawanie do treningu zadań typu „czy X jest Y?” na podstawie bazy wiedzy, by model nauczył się hierarchii pojęć.
  • Dwustopniowe podejścia: Gdzie najpierw neuralny moduł przetwarza język (np. zamienia pytanie na zapytanie logiczne), a potem symboliczny moduł (np. zapytanie w SPARQL do bazy) daje wynik, który znów ewentualnie formułuje modul generatywny w zdanie. To łączy swobodę języka (neural) ze ścisłością formalnego zapytania (symbol).

Korzyści hybryd: Literaturę przeglądając, znajdujemy opinie, że hybrydy mogą łagodzić słabości czysto neuronowych modeli (Synergizing Machine Learning & Symbolic Methods: A Survey on Hybrid Approaches to Natural Language Processing) (Synergizing Machine Learning & Symbolic Methods: A Survey on Hybrid Approaches to Natural Language Processing). Sieci dają przybliżone rozwiązania, ale nie zawsze logicznie poprawne – tu symbolika dopina rygor. Z drugiej strony, hybryda niweluje kruchość czysto symbolicznych systemów (gdzie brak odporności na błędy czy zmienność języka).

Przykład (symboliczna pamięć + neuronowy model): Zaimplementujmy mini hybrydę: model BERT będzie ekstraktorem encji, a następnie zapytamy prostą bazę wiedzy (słownik Python) o właściwość encji.

import spacy
nlp = spacy.load("en_core_web_sm")  # użyjemy spacy jako prostego ekstraktora encji

# Prosta baza wiedzy: stolice
capital_of = {"France": "Paris", "Germany": "Berlin", "Poland": "Warsaw"}

def answer_question(question):
    doc = nlp(question)
    country = None
    for ent in doc.ents:
        if ent.label_ == "GPE":  # geopolityczna jednostka
            country = ent.text
            break
    if country and country in capital_of:
        return capital_of[country]
    else:
        return "I don't know."

q = "What is the capital of France?"
print(q, "->", answer_question(q))

Tu mechanizm symboliczny to po prostu słownik capital_of, a mechanizm “uczący się” (choć tu wzięty z półki spacy, ale wyobraźmy że to modul neuronowy) identyfikuje, że w pytaniu chodzi o kraj (France). Odpowiedź generujemy już bezpośrednio z bazy symbolicznej. W dużej skali podobnie działały niektóre systemy Q&A przed erą end-to-end: parse pytania -> zapytanie do knowledge base -> formatowanie odpowiedzi.

W nowoczesnych hybrydach, miejsce spaCy mógłby zająć LLM, a miejsce słownika – ogromny graf wiedzy typu Wikidata. Lub odwrotnie: LLM generuje potencjalną odpowiedź i uzasadnienie, a symboliczny moduł sprawdza jej zgodność z wiedzą (np. cross-check z Wikipedią) i ewentualnie koryguje.

Ograniczenia podejść hybrydowych:

  • Złożoność implementacji: End-to-end neural model jest względnie prosty w użyciu – wrzucasz dane, dostajesz wyniki. Hybryda wymaga projektu architektury z wieloma komponentami, integracji ich, co może być trudniejsze w utrzymaniu i skalowaniu.
  • Trudność trenowania całości: Często komponenty symbolic i neural uczą się osobno. Marzeniem byłoby trenować je wspólnie (jakieś gradienty przez modul symbolic – ale to zwykle nienawiązywalne). Są metody jak reinforcement learning by dostroić neural modul na podstawie wyniku symbolic modul (np. RL gdy nagrodą jest czy odpowiedź logicznie poprawna). To aktywny obszar badań.
  • Interpretacja hybrydy może dalej być trudna: Choć modul symbolic jest interprewowalny, modul neural nie. Dla pełnej przejrzystości w krytycznych zastosowaniach wciąż to wyzwanie – w razie błędu nie zawsze wiadomo, czy wina leży po stronie sieci (źle zrozumiała) czy reguły (niepasująca).
  • Wymaganie wiedzy eksperckiej: Budowa komponentów symbolicznych (np. ontologii, reguł eksperckich) wymaga domenowej wiedzy, której często nie mamy w czystej postaci. Modele uczące się wypierają symboliczne systemy m.in. dlatego, że potrafią nauczyć się wiedzy z danych bez manualnego wprowadzania. Hybryda poniekąd przywraca potrzebę posiadania takiej wiedzy (chyba że jest automatycznie ekstraktowana – ale to znów rola ML w pipeline).

Przykłady 2022: W literaturze z tego okresu można znaleźć np. prace o fakt-checking z wykorzystaniem grafów wiedzy (Synergizing Machine Learning & Symbolic Methods: A Survey on Hybrid Approaches to Natural Language Processing), common-sense reasoning łączące GPT-3 z bazą ConceptNet, czy Logic-driven sentence generation (np. Plan-and-Write, gdzie plan jest symboliczną strukturą). Również systemy AutoML dla NLP, np. generujące programy (reguły) do obróbki tekstu z opisu – to pewna forma hybrydy, gdzie model buduje symboliczną procedurę.

Podsumowanie: Modele hybrydowe to próba wzięcia najlepszych cech AI sprzed ery deep learning (symboliczna wiedza i logika) i włączenia ich do nowoczesnych architektur. Rok 2022 to intensywny rozwój takiego myślenia, bo stało się jasne, że same LLM-y mają ograniczenia. W następnych etapach (2023+) zobaczymy jeszcze więcej integracji – np. systemy typu ChatGPT Plugins (gdzie plugin to zewnętrzne narzędzie, w sumie komponent symboliczny) czy architektury Vitality aware – modul LLM decyduje, czy odpowiedzieć samemu czy zasięgnąć zewnętrznej bazy.

10. Modele z pamięcią długoterminową (2023) – kontekst w długich interakcjach

Kontekst: Typowe transformatory, w tym dotychczas omawiane (BERT, GPT-2/3, T5) mają ograniczoną długość kontekstu – np. 512 czy 1024 tokeny. To oznacza, że nie potrafią w jednym przebiegu przetworzyć tekstu dłuższego niż ta granica. W praktyce wiele dokumentów czy rozmów ją przekracza. W dialogach (np. chatbocie) po kilkunastu wymianach kontekst łatwo przekroczy 1024 tokeny. Modele często wtedy „zapominają” o wcześniejszych partiach konwersacji (bo te tokeny nie mieszczą się już w oknie wejściowym).

W 2023 nastąpił więc ogromny nacisk na rozwój długoterminowej pamięci w modelach:

  • Z jednej strony OpenAI wprowadziło GPT-4 z kontekstem do 8k i 32k tokenów (to ~50 stron tekstu) – dzięki usprawnieniom architektury (optymalizacje atencji).
  • Antropic poszło dalej z modelem Claude 2, oferującym nawet 100k tokenów kontekstu (można mu dać całą powieść do streszczenia).
  • Pojawiły się prace badawcze nad efektywnymi mechanizmami atencji, które skalują się lepiej niż kwadratowo. Np. modele takie jak Longformer (Exploring the Transformer-XL: Handling Long Contexts in Text), BigBird, Transformer-XL, Reformer, Performer, Linformer – wszystkie starają się skrócić ogon złożoności z O(n^2) do O(n) lub O(n log n), np. stosując okna lokalne, atencję sparametryzowaną albo mechanizmy kompresji pamięci.
  • Inne podejście to dodanie pamięci zewnętrznej – np. architektura RMT (Recurrent Memory Transformer) czy koncepcja tzw. transformera z pętlą rekursywną – model przetwarza sekwencje partiami i aktualizuje swój stan pamięci, który przenoszony jest dalej (podobnie jak RNN, ale implementowane świadomie w transformerze). Np. praca “Augmenting Language Models with Long-Term Memory” (Wang et al. 2023) proponuje osobną sieć poboczną jako czytnik pamięci długotrwałej, co pozwala modelowi zapamiętać do 65k tokenów kontekstu i efektywnie je wykorzystywać (Augmenting Language Models with Long-Term Memory | OpenReview) (Augmenting Language Models with Long-Term Memory | OpenReview).
  • Również formaty czatu zaczęły uwzględniać mechanizmy streszczania lub zarządzania kontekstem. Np. ChatGPT zanim przekroczy limit, może robić summaries dotychczasowej rozmowy i podawać je sobie w kolejnych promptach (to takie miękkie rozwiązanie – nie architekturą, ale na poziomie aplikacji).

Dlaczego to ważne? Modele z długą pamięcią potrafią rozwiązywać zadania, które wcześniej były niemożliwe, np.:

  • Analiza całego dokumentu lub wielu dokumentów jednocześnie: Np. pytanie: „Które przepisy w tej ustawie odnoszą się do ochrony danych osobowych?” – można podać modelowi całą ustawę (powiedzmy 30 stron) i model to przeczyta i wyłuszczy odpowiedni fragment. Wcześniej trzeba by było dzielić tekst i kombinować z retrieval, co było niedoskonałe.
  • Rozmowy ciągnące się przez dziesiątki interakcji: Asystent AI powinien pamiętać, co użytkownik powiedział 2 godziny temu w czacie. Długa pamięć to umożliwia, co czyni interakcje bardziej spersonalizowanymi i spójnymi.
  • Zadania kreatywne długiego dystansu: Generowanie opowiadań, gdzie model musi pilnować fabuły i konsystencji na przestrzeni wielu akapitów. Lub utrzymanie stylu w długim eseju.
  • Kod i logi: Analiza dużych plików logów w całości, czy zrozumienie projektu kodu (kilka plików na raz) – to wymaga długiego kontekstu, by model budował powiązania między częściami.

Przykład (długa atencja): Użyjmy modelu Longformer (z kontekstem 4096) do analizy długiego tekstu. Wygenerujemy sztuczny tekst powtarzający pewną frazę daleko i zadać pytanie, czy model to wyłapie.

from transformers import AutoModelForQuestionAnswering, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
model = AutoModelForQuestionAnswering.from_pretrained("allenai/longformer-base-4096")

# Tworzymy długi kontekst z powtarzaniem informacji co jakiś czas
text = " ".join(["Kluczowe zdanie: NLP jest fascynujące."] + ["bla"]*3000 + ["NLP jest fascynujące."] + ["bla"]*3000)
question = "What is the key sentence about?"
inputs = tokenizer(question, text, return_tensors="pt")
outputs = model(**inputs)
answer_tokens = outputs["start_logits"].argmax(), outputs["end_logits"].argmax()
answer = tokenizer.decode(inputs["input_ids"][0, answer_tokens[0]:answer_tokens[1]+1])
print("Answer:", answer)

Ten kod tokenizuje pytanie i bardzo długi tekst (~6000 słów „bla” z wtrąconym dwa razy zdaniem „NLP jest fascynujące.”). Longformer dzięki swoim lokalnym oknom atencji (i globalnemu dla special tokens) powinien być w stanie znaleźć „Kluczowe zdanie: NLP jest fascynujące.” i zwrócić odpowiedź „NLP jest fascynujące.”. Standardowy BERT by nie mógł, bo 6000 tokenów by się nie zmieściło.

Zastosowania długiej pamięci:

  • Chatboty z kontekstem osobistym: Model pamięta preferencje i dane użytkownika z poprzednich rozmów (z założeniem etycznym, że użytkownik zgadza się na przechowywanie kontekstu).
  • Asystenci kodowania: Model może czytać cały projekt i dawać spójne sugestie z uwzględnieniem wszystkich modułów.
  • Przetwarzanie dokumentów prawnych, technicznych: Wyszukiwarki semantyczne, które na wejściu biorą cały zestaw dokumentów i od razu generują odpowiedź z referencjami – bez konieczności dzielenia pytania na subzapytania.
  • Pamięć konwersacyjna między sesjami: Np. asystent głosowy, który pamięta, o co pytaliśmy wczoraj (poprzez trzymanie historii jako dodatkowy kontekst do podpowiedzi modelowi).

Ograniczenia:

  • Koszt skalowania kontekstu: Nawet jeśli złożoność zredukowana np. do liniowej, to i tak wiele tokenów to więcej obliczeń i pamięci. 100k tokenów to ~100 stron – żeby to przetworzyć, nawet „efficient transformer” potrzebuje sporo zasobów. Często idzie to w parze z koniecznością by model był duży, by to zinternować.
  • Zapominanie i tak się zdarza: Modele nie “piszą notatek” jak ludzie – jeśli ważna informacja pojawiła się na stronie 1, a pytanie jest na stronie 100, model może gubić pewne szczegóły (chyba że architektura jak RMT stale dostarcza mu skrótów). To wciąż otwarte badanie: jak zapewnić, że model robustowo zachowuje info z początku? Jedna z metod to wprowadzanie mechanizmów odświeżania pamięci (np. recency bias w atencji lub pewne penalizacje).
  • Błędy akumulowane: Długi kontekst to więcej szans na drobne błędy interpretacji, które mogą się sumować. Np. drobne zmiany znaczenia, przekręcenie nazw, etc., mogą narastać. Dlatego czasem streszczanie lub segmentacja bywa jednak używana (dziel i rządź).
  • Trudność uczenia na tak długich sekwencjach: Wiele modeli długokontekstowych jest pre-trenowanych na dość krótkich sekwencjach i potem tylko dostrajanych na dłuższe. Ciężko zebrać i zprocesować GPU naraz kontekst 100k tokenów – stąd różne tricki jak curriculum learning (zaczynać od mniejszego kontekstu, zwiększać stopniowo).

Prace 2023: W literaturze mamy np. “Transformers with persistent memory” (dający sloty pamięci które przechodzą między segmentami) albo “Hierarchical Memory Transformer” (HMT: Hierarchical Memory Transformer for Long Context Language …), “Infinite context windows” (pomysły by model mógł streame’ować bez limitu). Również pojawia się pomysł łączenia retrieval (pamięć w bazie) i recurrence (pamięć w stanie) – np. ChatGPT obecnie nie ma stałej pamięci między sesjami, ale user może mu dostarczyć tzw. custom instructions (coś jak profil) – to manualny step.

Podsumowanie: Modele z długą pamięcią usiłują zbliżyć LLM do ludzkiej zdolności kontynuowania wątków i korzystania z wiedzy zdobytej wcześniej w rozmowie czy dokumencie. W pewnym sensie, jest to powrót do korzeni: pierwotnie RNN (LSTM) mogły w teorii czytać nieograniczone strumienie (w praktyce ograniczał gradient, ale architekturalnie nie było okna). Transformers z 2017 wprowadziły okno, bo tak było wydajniej. Teraz szuka się sposobu, by to okno otworzyć szerzej – czy to przez architekturę, czy sztuczki. W 2023 i dalej zapewne standardem staną się modele z kontekstem rzędu dziesiątek tysięcy tokenów. A to otwiera nowe możliwości aplikacji, jak choćby bazodanowe LLM (wrzucasz całego SQLa i dokumentację do prompta i zadajesz pytania), model as personal knowledge base (karmisz go swoimi notatkami z lat i pytasz „co mówiłem rok temu na ten temat?”) itp.

11. Modele rozumujące (OpenAI o1, 2024) – zaawansowane rozumowanie i wnioskowanie

Kontekst: Mimo że GPT-3 i GPT-4 były imponujące, wciąż zdarzały im się błędy w rozumowaniu. W 2022 zaproponowano metodę Chain-of-Thought – by skłonić model do wypisania kroków rozumowania, co poprawiło wyniki na zadaniach wymagających logiki (matematyka, łamigłówki). OpenAI poszło o krok dalej: w 2024 ogłosili nową serię modeli, nazwanych wewnętrznie o1 (i mniejszy wariant o1-mini), które mają wbudowany mechanizm rozumowania krok-po-kroku. Model OpenAI o1-preview pojawił się we wrześniu 2024 i został przedstawiony jako „model rozumujący” wykorzystujący chain-of-thought wewnętrznie (DeepSeek-R1 is shaking up the AI world) (Prompt Engineering for OpenAI’s O1 and O3-mini Reasoning Models).

Czym różni się model rozumujący od zwykłego LLM?

  • Model o1 został nauczony (m.in. przez RL z nagrodą oraz fine-tuning na rozwiązaniach) tego, by nie udzielać od razu odpowiedzi, lecz najpierw przeprowadzić wewnętrzny dialog rozumujący (Prompt Engineering for OpenAI’s O1 and O3-mini Reasoning Models). Ten łańcuch myśli może być nawet wyprowadzony na żądanie (to tzw. reasoning tokens). W praktyce o1 generuje sekwencję, która składa się z segmentów myśli (otagowanych specjalnym tokenem lub znacznikami) oraz finalnej odpowiedzi.
  • Model potrafi np. krok po kroku wyprowadzić rozwiązanie zadania matematycznego, testując różne możliwości i sam się sprawdzając (pojawiło się określenie, że model o1 nauczył się strategii self-verification and reflection (DeepSeek AI: Advancing Open-Source LLMs with MoE & Reinforcement Learning | DeepSeek-R1 & V3 Explained)).
  • Architekturalnie jest to nadal duży model transformera (prawdopodobnie porównywalny z GPT-4 pod względem parametru), ale trening został ukierunkowany na rozwiązywanie trudnych zadań, gdzie trzeba planować. Wykorzystano do tego reinforcement learning z generowaniem łańcucha myśli, dając modelowi nagrody za poprawne wnioskowanie wieloetapowe.

Umiejętności: OpenAI o1 według zapowiedzi znacznie lepiej radzi sobie z zadaniami, które wcześniej sprawiały problem:

  • Matematyka i kody: Rozwiązywanie zadań matematycznych, w szczególności takich jak olimpiady matematyczne, dowodzenie krokowe, programowanie złożonych algorytmów – model potrafi cierpliwie przejść przez poszczególne etapy i znaleźć błąd, zamiast zgadywać wynik od razu (DeepSeek-R1 is shaking up the AI world).
  • Logika i łamigłówki: Słynne zadania logiczne (jak puzzle z prawdomównym i kłamcą, zagadki typu Einstein puzzle) – model rozumujący lepiej eksploruje rozwiązania.
  • Pytania wymagające uzasadnienia: Np. “Why is the sky blue?” – model potrafi przedstawić wieloetapowe wnioskowanie (rozważa rozpraszanie światła, fizykę atmosfery) zanim udzieli odpowiedzi. Daje to pełniejsze i bardziej poprawne odpowiedzi.
  • „Myślenie na głos”: Co ciekawe, modele o1 można poprosić, by pokazały swój tok myślenia (OpenAI API umożliwia tryb z reasoning tokens). Wtedy użytkownik widzi np.:
    <think> Let me break it down. The riddle says... [kilka zdań analizy] ... So likely the answer is X. </think>
    The answer is X.
    Taki wgląd jest cenny do oceny, czy model nie popełnił gdzieś błędu w rozumowaniu (co nadal może się zdarzyć, choć rzadziej).
  • Lepsza spójność i unikanie halucynacji w złożonych zadaniach: Ponieważ model nie „skacze” do odpowiedzi, mniej halucynuje fakty – jeżeli czegoś nie wie, w trakcie myślenia może dojść do wniosku, że brakuje informacji, i odpowiednio stwierdzić brak danych zamiast zmyślać.

OpenAI o1 to prawdopodobnie rodzina modeli, planowana jako kolejny filar API obok GPT-4. Głośno było, że jest wolniejszy i droższy, bo generuje dużo reasoning tokens (do 30x więcej tekstu niż GPT-4 dla trudnych zadań) (DeepSeek-R1 is shaking up the AI world). Jednak DeepSeek-R1 (o którym za moment) pokazał, że można tę wydajność poprawić.

Przykład (zachowanie łańcucha rozumowania): Wyobraźmy sobie, że używamy API o1:

system_prompt = "<reasoning>assistant</reasoning>You are a reasoning assistant. Solve step-by-step."
user_prompt = "You're escaping a labyrinth, and there are three exits: A leads to fire, B leads to an assassin, C leads to a lion that hasn't eaten in 3 years. Which exit do you pick?"
response = openai.ChatCompletion.create(
  model="openai-o1-preview",
  messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}],
  max_tokens=200,
  temperature=0
)
print(response['choices'][0]['message']['content'])

Model o1 prawdopodobnie wygeneruje coś w stylu (przykład na podstawie znanego puzzle):

<think> The lion hasn't eaten in 3 years, which means the lion is dead. Fire and assassin are immediate threats. So exit C with the dead lion is safe. </think>
You should choose Exit C, because the lion would have died after not eating for 3 years.

Czyli najpierw myśli (w znaczniku <think>), potem daje odpowiedź. Dokładnie tak zrobił DeepSeek-R1 w swoim przykładzie (DeepSeek-R1 is shaking up the AI world) (DeepSeek-R1 is shaking up the AI world) – co wskazuje, że R1 naśladuje styl O1.

Ograniczenia modeli rozumujących:

  • Wolniejsze działanie: Jak wspomniano, generowanie obszernego toku myślenia to narzut. Dla użytkowych zastosowań często nie potrzebujemy widzieć łańcucha, ale model i tak może go produkować wewnętrznie (chyba że odetniemy).
  • Możliwe „zafiksowanie” lub błędne ścieżki: Model może utknąć w pętli rozumowania (np. powtarzać w kółko pewne rozważania). Użycie RL i heurystyk pewnie to minimalizuje, ale np. DeepMind wspominało w swoich pracach, że modele ze wstawkami reasoning często generowały zbyt długie i niekoniecznie potrzebne wywody. Trzeba więc je stroić, by wiedziały kiedy przestać.
  • Brak gwarancji 100% poprawności: Choć wydajność logiczna rośnie, model wciąż nie dowodzi matematycznie – to nie jest system CAS czy dowodzenia twierdzeń (na razie). Może popełnić błędy arytmetyczne w trakcie, choć rzadziej. Dlatego w krytycznych zastosowaniach (np. pomoc medyczna) wciąż potrzebna jest walidacja.
  • Koszty trenowania: O1 to pewnie efekt trenowania na własnym zbiorze zadań i RL. To droga rzecz – stąd open-source dopiero goni (DeepSeek to pierwsza jaskółka). Nie każdy developer zrobi sobie takiego „myślącego” LLM od zera.

Wpływ i przyszłość: Modele rozumujące jak O1 wytyczają kierunek: integracja LLM z mechanizmami systemu 2 (odniesienie do Kahnemana: system 1 intuicyjny vs system 2 analityczny). Można spodziewać się, że kolejne modele (np. GPT-5?) będą jeszcze bardziej zintegrowane z mechanizmami wnioskowania – być może wbudują np. symbolic planner wewnątrz architektury lub jeszcze lepiej będą wykorzystywać narzędzia do subzadań (co już w ChatGPT pluginach widzimy). Celem jest model, który zarówno ma intuicję (umie płynnie mówić, zna język potoczny), jak i logikę (umie policzyć, zaplanować, wyciągnąć poprawny wniosek).

OpenAI o1 to dość świeża sprawa (2024), ale już obserwujemy jego wpływ – np. wspomniany DeepSeek-R1 próbuje otwarcie dorównać mu i pokazał, że open source też może mieć „chain-of-thought wbudowany”.

12. DeepSeek-R1 (2025) – open-source’owy model łączący generację i rozumienie

Kontekst: Lata 2023-2025 to dynamiczny rozwój otwartoźródłowych modeli, które starają się dogonić (a nawet prześcignąć) komercyjne systemy jak GPT-4 czy O1. W szczególności w Chinach nastąpił boom na duże modele open-source wspierane rządowo i prywatnie. Jednym z przełomowych osiągnięć jest DeepSeek-R1 (2025) – pierwszy jawnie opublikowany model, który pod względem reasoning dorównuje zamkniętemu OpenAI O1 (DeepSeek AI: Advancing Open-Source LLMs with MoE & Reinforcement Learning | DeepSeek-R1 & V3 Explained).

Kim jest DeepSeek? To chińska firma/organizacja AI, która już wcześniej wydawała modele (DeepSeek LLM, DeepSeek Coder). R1 to ich pierwsza generacja modelu rozumującego. Wyróżniki DeepSeek-R1:

Osiągi DeepSeek-R1: Według raportu, R1 osiągnął porównywalne wyniki do OpenAI o1-1217 (wersja O1 z grudnia 2024) w zadaniach reasoning ([2501.12948] DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning). Na wielu testach edukacyjnych czy logicznych jest w ścisłej czołówce. R1 jest też silny jako model programistyczny – nie tak dobry jak specjalistyczne modele kodowe, ale dzięki chain-of-thought radzi sobie z trudnymi problemami algorithmicznymi (gdzie trzeba np. wymyślić nietrywialny algorytm i go zakodować) (DeepSeek-R1 is shaking up the AI world) (DeepSeek-R1 is shaking up the AI world).

Ponadto DeepSeek-R1 przychodzi w zestawie ze zdystylowanymi mniejszymi modelami (1.5B, 7B, 8B, 14B, 32B, 70B) ([2501.12948] DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning). Zespół użył R1 by nauczyć te mniejsze modele reasoning (traktując R1 jako nauczyciela generującego myśli i odpowiedzi dla mnóstwa pytań, a małe modele uczą się je naśladować) (DeepSeek-R1 is shaking up the AI world). Dzięki temu nawet ci, co nie mogą odpalić 671B MoE, mogą skorzystać z „R1-level reasoning” poprzez modele jak DeepSeek-R1-Distill-Llama-70B itp.

Przykład działania R1: Wspomniana zagadka z trzema wyjściami z labiryntu – to przykład z bloga DeepSeek (DeepSeek-R1 is shaking up the AI world) (DeepSeek-R1 is shaking up the AI world): Model generuje:

<think> Okay, so we have:
Exit A -> inferno (fire) -> instant death likely.
Exit B -> assassin -> highly lethal, but maybe there's a chance?
Exit C -> lion hasn't eaten in 3 years -> lion would be dead because no animal survives 3 years without food.
Thus, Exit C is safe as the lion is dead. </think>
The safest exit is C, since the lion would have died from starvation.

Widać tu pełen chain-of-thought (dość rozbudowany, argumentujący każdą opcję) i konkluzję. Styl jest bardzo podobny do założeń O1.

Ograniczenia DeepSeek-R1:

  • Choć open-source, jego pełna wersja 671B MoE jest trudna do uruchomienia poza centrami HPC. Jednak dzięki MoE i distillacji, można użyć 70B wersji, co jest już w zasięgu topowych GPU (8xA100 np.).
  • To wciąż model językowy, więc może halucynować fakty. Poprawiono reasoning, ale nie dodano bazy wiedzy zewnętrznej – więc jeśli nie ma informacji, może ją zmyślać (choć styl CoT może sprawić, że powie „nie jestem pewien, ale chyba X”).
  • Bywa zbyt gadatliwy: generuje obszerne wywody nawet gdy pytanie proste. To można kontrolować promptem (np. prośba o krótką odpowiedź).
  • Języki inne niż en/zh: R1 nie był trenowany wielojęzycznie poza chińskim i angielskim. Mógł pewne pojęcia innych języków wyłapać (bo pewnie w corpusu były fragmenty), ale nie jest tak uniwersalny jak GPT-4, który zdaje się radzić sobie w kilkunastu językach. Więc do np. polskiego może być potrzebny prompt po angielsku lub fine-tune.
  • Bezpieczniki i wartości: OpenAI dużą wagę przykłada do RLHF alignment, by model był „ugrzeczniony”. R1 jako open model może nie mieć tak silnych ograniczeń – co jest mieczem obosiecznym: daje wolność użycia np. w aplikacjach researchowych, ale stawia odpowiedzialność na użytkownika by go nie nadużywał.

Wpływ: DeepSeek-R1 pokazał, że społeczność open-source nadąża za korporacyjną AI. Może to zapoczątkować szybkie iteracje w światku OSS: w 2025 prawdopodobnie zobaczymy kolejne hybrydy i usprawnienia R1 przez niezależnych programistów. Już fine-tune’ują R1 do konkretnych zastosowań (kod, medycyna, itp.).

Dla programistów oznacza to, że za darmo mają dostęp do modelu, który:

  • Generuje wysokiej jakości odpowiedzi z wyjaśnieniami (co może być cenne do debugowania lub edukacji).
  • Może być sam fine-tune’owany (bo jest open) do własnych danych – np. można zrobić eksperta od swojej bazy wiedzy, łącząc R1 z retrieval.
  • Może być użyty lokalnie (przynajmniej w zdystylowanej formie) bez wysyłania danych na zewnątrz – ważne dla prywatności.

Przykład użycia (distill): Pokażmy jak można użyć zdystylowanej wersji R1 7B do rozwiązania zagadki:

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Llama-8B")
model = AutoModelForCausalLM.from_pretrained("deepseek-ai/DeepSeek-R1-Distill-Llama-8B")

prompt = "<think>Let's break it down step by step.<think>\nQuestion: If I have 10 apples and give away 4, how many left?\nAnswer:"
inputs = tokenizer(prompt, return_tensors="pt")
output = model.generate(**inputs, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))

Zakładamy, że model rozumie tag <think> (w distill może to być inne oznaczenie, zależnie jak go nauczyli). Powinien wygenerować coś jak:

<think> Starting with 10 apples. Giving away 4 reduces count. 10 - 4 = 6. So 6 apples left. </think>
6

Distill 8B może nie być aż tak biegły, ale idea to, że nawet mniejszy model nauczył się formatu.

Podsumowanie: DeepSeek-R1 to zwieńczenie wielu trendów: duża skala, reasoning chain-of-thought, open source, dwujęzyczność, distillacja. Jest pomostem między światem badań a produktem – bo pozwala w praktyce wdrożyć zaawansowane funkcje GPT-4/O1 bez ich posiadania. Wraz z nim, rok 2025 zapowiada się jako czas, gdy kombinacja generacji (jak GPT) z rozumowaniem (jak systemy eksperckie) stanie się standardem w narzędziach programistycznych, asystentach i innych aplikacjach NLP. Programista posiadający takiego modelu może zautomatyzować bardzo złożone zadania – np. kazać mu przeanalizować wymagania projektowe i wygenerować plan działania, prosząc by wyraźnie uzasadnił każdą decyzję (co zrobi w chain-of-thought). To trochę jak posiadać w zespole myślącego asystenta, a nie tylko „autouzupełniacz”.


Podsumowanie

W ciągu kilkunastu lat (2013–2025) NLP dokonało skoku od statycznych wektorów słów do gigantycznych modeli potrafiących rozumować jak człowiek. Przeszliśmy przez etapy:

  • Reprezentacje ciągłe (Word2Vec) – maszyny zaczęły rozumieć podobieństwa słów.
  • Głębokie sieci sekwencyjne (LSTM, seq2seq) – modele nauczyły się przetwarzać całe zdania i wykonywać złożone transformacje (tłumaczenie, summarization).
  • Transformery i pretrenowanie (BERT, GPT-2) – skalowanie umożliwiło nauczenie modeli szerokiej wiedzy i umiejętności językowych, które przenoszą się na wiele zadań.
  • Modele wielkie i ujednolicone (T5, GPT-3) – okazało się, że jeden duży model potrafi zrobić prawie wszystko z odrobiną wskazówek, co zmieniło sposób korzystania z AI (prompt zamiast trenowania od zera).
  • Integracja wiedzy i logiki (modele hybrydowe, długie konteksy) – reagując na słabości czysto statystycznych modeli, połączono je z symboliką i wydłużono ich „pamięć”, zbliżając do ludzkiego sposobu rozumowania ciągłego i korzystania z zewn. wiedzy.
  • Rozumowanie (OpenAI O1, DeepSeek-R1) – najnowsza generacja, gdzie modele nie tylko mówią, ale i myślą w zrozumiały sposób.

Dla doświadczonych programistów oznacza to, że dzisiejsze narzędzia NLP:

  • Są znacznie łatwiejsze w użyciu niż kiedyś (bo wiele jest pretrenowanych, wystarczy je pobrać i użyć/promptować),
  • Mogą rozwiązać znacznie bardziej skomplikowane problemy (nawet takie, które kiedyś wymagały logiki eksperckiej),
  • Nadal jednak wymagają zrozumienia ich działania (np. wiedzy o tym, że model może halucynować, albo że potrzebuje odpowiedniego promptu).

Każdy z omówionych kamieni milowych ma bogatą literaturę:

Wejście w ten świat może wydawać się trudne, ale mając solidne podstawy programistyczne, warto krok po kroku zgłębiać te tematy – czytając publikacje naukowe i eksperymentując z modelami. Mamy nadzieję, że ten artykuł zbudował u Czytelnika mentalny model ewolucji NLP i zachęci do dalszej eksploracji poprzez lekturę wskazanych źródeł oraz praktyczne próby z kodem. NLP stoi na progu ekscytujących możliwości – a jednocześnie wyzwań – a wiedza o tych kluczowych osiągnięciach to najlepszy przewodnik, by świadomie i twórczo korzystać z najnowszych narzędzi.

Źródła do dalszej nauki:

Za kulisami - jak powstał ten artykuł?

Pierwsze testy usługi DeepResearch wskazują, że skuteczny prompting to nadal ważny element komunikacji z ChatemGPT - nawet w planie Pro. Co więcej, w przypadku usługi DeepResearch na finalny rezultat możemy czekać dobrych kilka minut (tutaj - ponad 20 minut w oparciu o 24 źródła!), więc początkowa jakość prompta tym bardziej ma znaczenie - w końcu nie ma tutaj mowy o szybkiej iteracji nad ostatecznym tekstem.

Biorąc pod uwagę publicznie dostępne testy i rekomendacje, do stworzenia artykułu wykorzystaliśmy następujące kroki:

  1. Utworzenie wstępnej struktury tekstu z GPT-4o i SearchGPT
  2. Ręczne zdefiniowanie 5 pytań, na które odpowiedzi pozwoliłyby zrozumieć pierwszy fragment tekstu na oczekiwanym poziomie szczegółowości
  3. Przekazanie pytań do modelu i wygenerowanie pozostałych pytań a’la few-shot prompt
  4. Krytyka struktury z o1 - zapewnienie ciągłości tekstu i unikanie “skokowego” przejścia między pojęciami
  5. Przekazanie prompta opartego o listę pytań do GPT-4o/o3-mini z trybem DeepResearch

W trybie DeepResearch model zawsze rozpoczyna pracę od doprecyzowania kontekstu - przykładowo:

Aby przygotować jak najbardziej wartościowy artykuł, chciałbym doprecyzować kilka kwestii:

1. Czy artykuł powinien być skoncentrowany wyłącznie na modelach i algorytmach NLP, czy również na ich zastosowaniach biznesowych i produktowych?
2. Czy zależy Ci na omówieniu wyzwań i ograniczeń, jakie napotkano na różnych etapach rozwoju NLP?
3. Czy w sekcji o najnowszych trendach (GPT-4o, modele rozumujące) uwzględnić spekulacje na temat przyszłości NLP i potencjalnych kierunków rozwoju?
4. Czy preferujesz głównie źródła akademickie (artykuły naukowe, Arxiv) czy również branżowe raporty, wpisy blogowe i dokumentacje narzędzi open-source?

Daj mi znać, a zabieram się do pracy!

Po uzyskaniu odpowiedzi model zabrał się do pracy.

Początek pracy nad artykułem

Na końcu pozostała nam ręczna edycja i korekta treści (weryfikacja polskich tłumaczeń, usuwanie okazjonalnych powtórzeń, formatowanie Markdown). W efekcie powstał artykuł, który zamieściliśmy powyżej.

Finalny prompt prezentujemy poniżej:

Jesteś technical writerem i ekspertem NLP - napisz artykuł opisujący najważniejsze osiągnięcia tej dziedziny bazując na przedstawionej poniżej strukturze. Tekst powinien mieć formę spójnego artykułu na granicy pracy naukowej i być kierowany do programistów z doświadczeniem, którzy potrzebują zrozumiałych modeli mentalnych, analogii i przykładów do wejścia w świat NLP. Załóż znajomość Pythona ale wyłącznie podstawową znajomość terminologii NLP - ostrożnie wprowadzaj nowe pojęcia i konsekwentnie odpowiadaj na zadane w tekście pytania.

1. Word2Vec (2013)

Cel: Wprowadzenie ciągłych reprezentacji słów (embeddings) oraz zmiana paradygmatu w modelowaniu semantyki.
Pytania:
	1.	Kontekst historyczny: Jak wyglądał krajobraz NLP przed wprowadzeniem word2vec? Jakie metody reprezentacji tekstu (np. worki słów, reprezentacje jednowymiarowe) były stosowane i jakie miały ograniczenia?
	2.	Definicja i mechanizm: Czym dokładnie jest word2vec? Jak działają modele CBOW (Continuous Bag-of-Words) oraz Skip-Gram, i jakie korzyści przynoszą?
	3.	Przykład implementacji: Jak można wykorzystać bibliotekę Gensim w Pythonie, aby zbudować i wytrenować model word2vec na przykładowym zbiorze tekstowym?
	4.	Ograniczenia: Jakie były główne słabe strony word2vec (np. brak uwzględnienia kolejności słów, ograniczenia w kontekście) oraz jakie pytania badawcze pozostały otwarte?
	5.	Źródła wiedzy: Gdzie można znaleźć szczegółowe publikacje, dokumentację oraz przykłady kodu dotyczące word2vec, aby zgłębić techniczne aspekty tego podejścia?

2. Wprowadzenie architektury LSTM do NLP (2014)

Cel: Rozwiązanie problemów modelowania sekwencyjnego, takich jak zależności długoterminowe, które dotyczyły wcześniejszych metod.
Pytania:
	1.	Potrzeba modelowania sekwencyjnego: Jakie problemy wynikające z braku odpowiedniego modelowania sekwencji (np. utrata informacji o kolejności, problemy z długoterminowym zapamiętywaniem) były widoczne przed zastosowaniem LSTM?
	2.	Mechanizm działania: Jak działają LSTM, w szczególności rola bramek (wejścia, zapominania, wyjścia) oraz jak pomagają one w przechowywaniu długoterminowych zależności?
	3.	Przykład implementacji: Czy możesz zaprezentować przykład implementacji prostego modelu LSTM (np. w Keras lub PyTorch) do analizy sekwencyjnych danych tekstowych, który ilustruje przetwarzanie kolejności?
	4.	Ograniczenia i wyzwania: Jakie ograniczenia posiadają modele LSTM, takie jak trudności w równoległym przetwarzaniu czy problemy ze skalowaniem do bardzo długich sekwencji, i jak te kwestie skierowały badania w stronę kolejnych rozwiązań?
	5.	Literatura i zasoby: Gdzie można znaleźć dogłębne opracowania, artykuły naukowe i dokumentację techniczną dotyczącą LSTM i ich zastosowania w NLP?

3. Architektura Seq2Seq (2015)

Cel: Umożliwienie mapowania jednej sekwencji (np. zdania w języku źródłowym) na inną (np. tłumaczenie) przy użyciu pary sieci – enkodera i dekodera.
Pytania:
	1.	Przyczyny rozwoju: Jakie ograniczenia pojedynczych modeli sekwencyjnych, takich jak LSTM, utrudniały wykonywanie zadań wymagających przekształcenia sekwencji (np. tłumaczenie maszynowe), i dlaczego potrzebny był nowy paradygmat?
	2.	Budowa modelu: Jak zbudowana jest architektura seq2seq? Jak współdziałają enkoder i dekoder, a także jak wprowadzany jest mechanizm uwagi (attention), aby poprawić wyniki?
	3.	Implementacja w praktyce: Czy możesz przedstawić przykładowy kod w Pythonie (np. z wykorzystaniem TensorFlow lub PyTorch) implementujący model seq2seq do prostego zadania tłumaczenia lub streszczania tekstu?
	4.	Wyzwania: Jakie techniczne wyzwania (np. problem zanikającego gradientu, trudności z obsługą długich sekwencji) napotykano przy budowie pierwszych modeli seq2seq i jak te problemy zostały zidentyfikowane?
	5.	Gdzie szukać wiedzy: Jakie publikacje, repozytoria oraz dokumentacje stanowią dobre źródło wiedzy o architekturze seq2seq i jej ewolucji?

4. Publikacja BERT przez Google (2018)

Cel: Zmiana podejścia do reprezentacji kontekstu, dzięki dwukierunkowemu trenowaniu Transformerów, co znacznie poprawiło jakość rozumienia tekstu.
Pytania:
	1.	Kontekst przed BERT: Jakie metody reprezentacji kontekstu stosowano przed pojawieniem się BERT, i jakie ograniczenia wynikały z jednokierunkowych podejść?
	2.	Mechanizm BERT: W jaki sposób BERT wykorzystuje architekturę Transformer do generowania głęboko kontekstowych, dwukierunkowych reprezentacji słów?
	3.	Przykład zastosowania: Czy możesz zaprezentować przykładową implementację w Pythonie (np. z biblioteką Hugging Face Transformers) pokazującą, jak wykorzystać BERT do zadania klasyfikacji tekstu lub odpowiadania na pytania?
	4.	Wyzwania i ograniczenia: Jakie problemy związane z obliczeniami, zużyciem pamięci oraz maksymalną długością sekwencji wiążą się z trenowaniem i wdrażaniem BERT?
	5.	Źródła i literatura: Gdzie można znaleźć kluczowe publikacje, dokumentację oraz studia przypadków technicznych dotyczących BERT i jego wariantów?

5. Wprowadzenie GPT-2 przez OpenAI (2019)

Cel: Przełom w generowaniu tekstu przy użyciu transformera, pokazujący skalowalność modeli generatywnych i ich zdolność do tworzenia spójnych tekstów.
Pytania:
	1.	Problematyka generatywna: Jakie były ograniczenia wcześniejszych modeli generatywnych w kontekście spójności tekstu i utrzymania kontekstu, zanim pojawił się GPT-2?
	2.	Architektura GPT-2: Co wyróżnia GPT-2 pod względem konstrukcji (m.in. architektura transformera, skalowanie liczby parametrów) i w jaki sposób wpływa to na jakość generowanego tekstu?
	3.	Implementacja przykładowa: Czy możesz przedstawić przykład użycia GPT-2 w Pythonie (poprzez API lub open-source’ową implementację), który ilustruje generowanie tekstu na podstawie zadawanego promptu?
	4.	Ograniczenia i etyka: Jakie wyzwania technologiczne (np. ogromne wymagania obliczeniowe) oraz kwestie etyczne (np. stronniczość, możliwość generowania dezinformacji) wiążą się z GPT-2?
	5.	Gdzie szukać wiedzy: Jakie źródła – publikacje, blogi techniczne, repozytoria – oferują dogłębną analizę GPT-2 i jego zastosowań?

6. Modele wielojęzyczne (2020): mBERT, XLM-R

Cel: Umożliwienie przetwarzania wielu języków w jednym modelu, eliminując konieczność trenowania oddzielnych modeli dla każdego języka.
Pytania:
	1.	Wyzwania wielojęzyczności: Jakie problemy pojawiały się przy tradycyjnym, jednolingwistycznym podejściu do NLP, zwłaszcza w kontekście globalnych zastosowań?
	2.	Rozwiązania wielojęzyczne: W jaki sposób modele takie jak mBERT i XLM-R wykorzystują wspólną przestrzeń reprezentacji, aby obsługiwać wiele języków jednocześnie?
	3.	Przykład implementacji: Czy możesz przedstawić przykład użycia modelu mBERT lub XLM-R w Pythonie, który ilustruje analizę tekstu w co najmniej dwóch językach?
	4.	Ograniczenia i kompromisy: Jakie kompromisy (np. ryzyko negatywnej interferencji między językami, większe wymagania obliczeniowe) pojawiają się przy stosowaniu modeli wielojęzycznych?
	5.	Źródła wiedzy: Gdzie znaleźć dokumentację, porównawcze badania oraz publikacje techniczne na temat wielojęzycznych modeli NLP?

7. Model T5 (2020)

Cel: Ujednolicenie podejścia do zadań NLP poprzez traktowanie ich wszystkich jako problemów „tekst-na-tekst”.
Pytania:
	1.	Potrzeba ujednolicenia: Jakie wyzwania wynikały z istnienia wielu dedykowanych modeli do różnych zadań NLP i dlaczego warto było podejść do problemu w sposób uniwersalny?
	2.	Idea tekst-na-tekst: Jak model T5 przekształca każde zadanie – od tłumaczenia, przez streszczanie, aż po odpowiadanie na pytania – w problem przetwarzania tekstu na tekst?
	3.	Implementacja praktyczna: Czy możesz przedstawić przykład w Pythonie (np. z użyciem biblioteki Transformers) pokazujący, jak wykorzystać T5 do zadania streszczania tekstu?
	4.	Wyzwania i ograniczenia: Jakie ograniczenia niesie za sobą podejście tekst-na-tekst, np. w kontekście wymagań dotyczących danych treningowych i zasobożerności modelu?
	5.	Literatura i dokumentacja: Gdzie szukać szczegółowych opracowań, tutoriali i badań technicznych dotyczących T5 oraz jego wariantów (takich jak mT5)?

8. Model GPT-3 (2021)

Cel: Skalowanie architektury transformera do 175 miliardów parametrów, co umożliwiło osiągnięcie wysokiej jakości generacji języka przy minimalnym dodatkowym trenowaniu.
Pytania:
	1.	Ewolucja generatywnych modeli: Jakie ograniczenia wcześniejszych generatywnych modeli stanowiły impuls do stworzenia GPT-3, szczególnie w kontekście zadań zero-shot i few-shot?
	2.	Skalowalność i efekty: Co oznacza skalowanie modelu do setek miliardów parametrów i jak wpływa to na zdolność GPT-3 do rozumienia i generowania tekstu?
	3.	Przykładowe użycie: Czy możesz zaprezentować przykład użycia API GPT-3 w Pythonie, demonstrujący jego wszechstronność – na przykład w generowaniu kodu lub rozwiązywaniu problemów?
	4.	Ograniczenia oraz wyzwania: Jakie problemy (np. koszty trenowania, kwestie etyczne, zarządzanie stronniczością) wiążą się z wykorzystaniem modeli o takiej skali?
	5.	Źródła: Jakie są najlepsze publikacje, dokumentacje i analizy techniczne, które szczegółowo omawiają budowę i zastosowania GPT-3?

9. Modele hybrydowe (2022)

Cel: Integracja podejść głębokiego uczenia z metodami symbolicznymi w celu ulepszenia zdolności logicznego rozumowania i interpretacji struktury języka.
Pytania:
	1.	Motywacja hybrydowości: Jakie ograniczenia czysto neuronowych modeli NLP (np. brak explicite zdefiniowanej logiki, trudność w interpretacji) doprowadziły do zainteresowania podejściami hybrydowymi?
	2.	Mechanizm integracji: W jaki sposób modele hybrydowe łączą tradycyjne metody symboliczne z potęgą głębokiego uczenia, by osiągnąć lepsze rezultaty w złożonych zadaniach?
	3.	Implementacja: Czy możesz przedstawić fragment pseudokodu lub przykład w Pythonie ilustrujący, jak w praktyce można zintegrować komponenty symboliczne z sieciami neuronowymi w rozwiązaniu NLP?
	4.	Wyzwania techniczne: Jakie trudności (np. integracja, skalowalność, interpretowalność wyników) napotykają modele hybrydowe i jakie wnioski z tych wyzwań wyniknęły dla przyszłych badań?
	5.	Gdzie szukać wiedzy: Jakie źródła – artykuły, konferencje, repozytoria – oferują dogłębne analizy i przykłady implementacji modeli hybrydowych?

10. Modele z pamięcią długoterminową (2023)

Cel: Rozwiązanie problemu utraty kontekstu przy długotrwałych interakcjach, co jest kluczowe dla aplikacji takich jak chatboty i systemy dialogowe.
Pytania:
	1.	Problem kontekstu: Jakie problemy związane z utrzymaniem kontekstu występowały w poprzednich modelach NLP, szczególnie przy długich sekwencjach interakcji?
	2.	Nowe mechanizmy: W jaki sposób nowe modele z wbudowaną pamięcią długoterminową (np. zewnętrzne moduły pamięci lub zmodyfikowane architektury Transformer) rozwiązują problem utraty kontekstu?
	3.	Przykład wdrożenia: Czy możesz przedstawić przykładową implementację w Pythonie, pokazującą, jak zintegrować mechanizm długoterminowej pamięci w modelu NLP (np. dla systemu dialogowego)?
	4.	Ograniczenia: Jakie techniczne i obliczeniowe wyzwania (np. wzrost złożoności modelu, trudności z trenowaniem) wiążą się z implementacją długoterminowej pamięci?
	5.	Źródła: Gdzie można znaleźć dokumentację, artykuły naukowe i przykłady kodu dotyczące modeli z pamięcią długoterminową?

11. Modele rozumujące (o1) przez OpenAI (2024)

Cel: Przekroczenie dotychczasowych ograniczeń generatywnych modeli poprzez integrację mechanizmów zdolnych do zaawansowanego rozumowania i wnioskowania.
Pytania:
	1.	Potrzeba rozumowania: Jakie luki w zdolności wcześniejszych modeli do logicznego wnioskowania i rozwiązywania problemów (np. matematycznych, programistycznych) spowodowały rozwój modeli rozumujących takich jak o1?
	2.	Specyfika architektury: Czym model o1 różni się od swoich poprzedników pod względem architektonicznym i funkcjonalnym, aby skutecznie podejmować złożone zadania wymagające rozumowania?
	3.	Implementacja przykładowa: Czy możesz zaprezentować przykład w Pythonie (np. przy użyciu odpowiedniego API) ilustrujący, jak model o1 radzi sobie z zadaniem wymagającym logicznego myślenia, np. rozwiązywaniem problemów matematycznych?
	4.	Wyzwania i ograniczenia: Jakie problemy (np. interpretowalność wyników, specyficzność domenowa) nadal stanowią wyzwanie dla modeli rozumujących, i jakie kierunki badań mogą je pokonać?
	5.	Źródła wiedzy: Gdzie znaleźć szczegółowe publikacje, raporty techniczne i studia przypadków opisujące działanie oraz ewolucję modelu o1?

12. DeepSeek-R1 (2025)

Cel: Najnowszy przełom – open-source’owy model łączący zaawansowane zdolności rozumowania z wysoką wydajnością, odpowiadający na potrzeby społeczności badawczej i przemysłowej.
Pytania:
	1.	Motywacja i kontekst: Jakie ograniczenia modeli rozumujących i generatywnych poprzedzających DeepSeek-R1 skłoniły badaczy do opracowania tego rozwiązania?
	2.	Innowacje architektoniczne: Jakie kluczowe innowacje (np. optymalizacje architektury, otwarty charakter projektu) wyróżniają DeepSeek-R1 w porównaniu do modeli takich jak o1?
	3.	Przykład zastosowania: Czy możesz przedstawić fragment przykładowego kodu w Pythonie, który ilustruje, jak DeepSeek-R1 radzi sobie z złożonym zadaniem integrującym rozumienie tekstu, generację treści oraz elementy analizy programistycznej?
	4.	Wyzwania wdrożeniowe: Jakie bariery technologiczne i operacyjne (np. skalowalność, integracja z istniejącymi systemami, kwestie etyczne) należy rozwiązać przy wdrażaniu DeepSeek-R1 w praktycznych aplikacjach?
	5.	Dostęp do wiedzy: Gdzie społeczność badawcza i programiści mogą znaleźć repozytoria, dokumentację oraz szczegółowe opracowania techniczne związane z DeepSeek-R1?

Każdy zestaw pytań został skonstruowany tak, aby najpierw wprowadzić kontekst historyczny i wyjaśnić, dlaczego pojawiła się dana innowacja, następnie opisać mechanizmy techniczne i praktyczne przykłady implementacji, a na końcu wskazać ograniczenia oraz źródła wiedzy umożliwiające dalsze pogłębianie tematu.

Jeśli macie pytania lub sugestie dotyczące trybu DeepResearch, dajcie znać! Uwzględnimy je w kolejnych rozmowach z ChatemGPT.

Newsletter Opanuj AI

Subskrybuj ręcznie selekcjonowane materiały z obszarów AI i rynku nowych technologii, które pomagają dowozić lepsze rezultaty i budować kulturę innowacji

Zapisując się do newslettera akceptujesz naszą politykę prywatności.

W każdy poniedziałek
Otrzymuj podsumowanie najważniejszych informacji z branży AI i nowych technologii. Gwarantujemy zero spamu i tylko wartościowe treści.
Tylko najlepsze materiały
Materiały zamieszczane w newsletterze przechodzą proces selekcji, gdzie wymagamy jakości i możliwej do wykorzystania wiedzy.