<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Paweł Dubiel Tech Blog: Słownik</title>
  <link>https://paweldubiel.com/</link>
  <atom:link href="https://paweldubiel.com/glossary.xml" rel="self" type="application/rss+xml" />
  <description>Notatki o AI, modelach językowych i inżynierii oprogramowania.</description>
  <language>pl-PL</language>
  <lastBuildDate>Mon, 12 Oct 2026 00:00:00 GMT</lastBuildDate>
<item>
  <title>Validation Set</title>
  <link>https://paweldubiel.com/glossary/validation-set</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/validation-set</guid>
  <pubDate>Mon, 12 Oct 2026 07:17:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Prowadzisz budkę z lodami i chcesz przewidywać dzienną sprzedaż z temperatury. Masz trzy zapisane dni: przy 20°C sprzedano 20 porcji, przy 22°C — 30, a przy 24°C — 28.</description>
  <content:encoded><![CDATA[<p>Prowadzisz budkę z lodami i chcesz przewidywać dzienną sprzedaż z temperatury. Masz trzy zapisane dni: przy 20°C sprzedano 20 porcji, przy 22°C — 30, a przy 24°C — 28. Sprawdzasz trzy reguły: zawsze 24 porcje, prostą linię oraz krzywą przechodzącą dokładnie przez wszystkie trzy wyniki. Ostatnia nie popełnia w zeszycie ani jednego błędu. Czy powinna planować jutrzejszy zapas?</p>
<p>Tego nie rozstrzygnie ponowne sprawdzenie tych samych dni. Giętka reguła mogła dopasować się także do przypadku, choćby wyjątkowo licznej wycieczki przy 22°C. Zanim zaczniesz dobierać regułę, odkładasz inne dni do porównania kandydatów. <strong>Validation Set</strong> to wydzielona część danych używana do wyboru modelu lub jego ustawień, a nie do dopasowywania jego uczonych liczb. Taki podział opisują <a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio i Courville, <em>Deep Learning</em>, §5.3</a>.</p>
<p><img src="https://paweldubiel.com/assets/validation-set-tasting-tray-and-sealed-sample.webp" alt="Trzy próbki lodów przygotowane do porównania oraz oddzielny pojemnik z nienaruszoną plombą: metafora danych do wyboru i osobnej końcowej oceny." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="zeszyt-do-nauki-osobne-dni-do-wyboru">Zeszyt do nauki, osobne dni do wyboru</h2>
<p>Reguły i ich liczby ustalamy wyłącznie na danych uczących. Linia przewiduje dwukrotność temperatury minus 20. Krzywa jest łukiem dobranym do trzech punktów z zeszytu. Średni błąd bezwzględny oznacza tutaj: policz, o ile porcji pomyliła się prognoza każdego dnia, pomiń znak i uśrednij.</p>
<p>Na odłożonych dniach 21°C, 23°C i 25°C sprzedano odpowiednio 23, 25 i 31 porcji. Krzywa przewiduje 26,5, 30,5 i 22,5; jej średni błąd wynosi około 5,83 porcji. Linia przewiduje 22, 26 i 30: błąd to 1 porcja. Na tej podstawie wybieramy linię, choć w zeszycie przegrywała 2 do 0. <strong>Validation Set nie poprawił żadnej reguły; pomógł wybrać spośród trzech.</strong> Dane są wymyślone, a ułamkowe prognozy oznaczają oczekiwaną sprzedaż, nie dzielenie jednej porcji.</p>
<div id="validation-set-lab"></div>
<h2 id="po-wyborze-potrzebna-jest-jeszcze-końcowa-ocena">Po wyborze potrzebna jest jeszcze końcowa ocena</h2>
<p>Dni wykorzystane do wyboru już wpłynęły na decyzję. Dlatego trzecia, rozłączna część danych — <em>test set</em> — służy dopiero do oceny ustalonego rozwiązania. W przykładzie linia na dwóch wcześniej nieodsłoniętych dniach myli się średnio o 1 porcję. Jeżeli po obejrzeniu tego wyniku zmienisz regułę, te dni również zaczynają służyć wyborowi; tracą rolę niezależnego testu (§5.3).</p>
<p>To ważne ograniczenie: po wielu próbach można dopasować wybór do samego Validation Set i uzyskać zbyt optymistyczny wynik. Trzy odłożone dni są tu tylko pomocą dydaktyczną, nie wiarygodną oceną rzeczywistej sprzedaży. Żaden ustalony procent podziału nie gwarantuje dobrego pomiaru.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/overfitting">Overfitting</a> opisuje nadmierne dopasowanie do przykładów uczących; osobne dane pomagają zauważyć jego skutek.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> jest dalszą nauką gotowego modelu; Validation Set może służyć do wyboru ustawień tej nauki.</li>
<li><a href="https://paweldubiel.com/glossary/cross-entropy">Cross-entropy</a> to inny sposób liczenia błędu, często używany dla przewidywanego tekstu; rozdział ról danych pozostaje taki sam.</li>
</ul>
<p><em>Tekst i ilustrację przygotowano z pomocą AI. Dane, reguły i demonstracja są własnym uproszczonym przykładem; ilustracja jest metaforą wyboru i zachowania osobnej próbki.</em></p>]]></content:encoded>
</item>
<item>
  <title>Overfitting</title>
  <link>https://paweldubiel.com/glossary/overfitting</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/overfitting</guid>
  <pubDate>Sun, 11 Oct 2026 15:59:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Prowadzisz budkę z lodami. Przez 10 dni zapisywałeś w zeszycie temperaturę w południe i liczbę sprzedanych gałek. Chcesz zrobić z tych notatek regułę: jutro ma być 24°C, ile lodów przygotować?</description>
  <content:encoded><![CDATA[<p>Prowadzisz budkę z lodami. Przez 10 dni zapisywałeś w zeszycie temperaturę w południe i liczbę sprzedanych gałek. Chcesz zrobić z tych notatek regułę: jutro ma być 24°C, ile lodów przygotować?</p>
<p>Najprostsza reguła to prosta linia: „każdy stopień więcej to kilka gałek więcej”. W przykładzie z tej notatki myli się ona na zapisanych dniach typowo o 27,5 gałki, bo nie widzi, że w największy upał sprzedaż spada. Można więc dać regule więcej swobody i pozwolić krzywej zakręcać. Najbardziej giętka z wypróbowanych krzywych przechodzi dokładnie przez wszystkie 10 punktów. Jej błąd na dniach z zeszytu wynosi 0.</p>
<p>Wygląda to na regułę idealną. Tyle że dni z zeszytu już minęły, a reguła ma działać jutro. Na 400 nowych dniach z tej samej budki „idealna” krzywa myli się typowo o 236,5 gałki. Umiarkowanie giętka krzywa, która na zeszycie wypadała gorzej (10,9), na nowych dniach myli się o 16,8.</p>
<p><strong>Overfitting</strong> to sytuacja, w której model ma mały błąd na danych użytych do nauki, a zbyt duży w porównaniu z nim błąd na nowych danych tego samego rodzaju (<a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio i Courville, <em>Deep Learning</em>, §5.2</a>). Model dopasował się do cech swojego zbioru, które poza nim się nie powtarzają. Odwrotny kłopot nazywa się <strong>underfitting</strong>: reguła jest za prosta, żeby dobrze opisać nawet dane, które widziała. Tak zachowuje się prosta linia z naszego przykładu.</p>
<p><img src="https://paweldubiel.com/assets/overfitting-smooth-rule-versus-tangled-line-through-every-point.webp" alt="Dwie budki z lodami obok siebie: nad pierwszą gładka linia biegnie łagodnym łukiem między punktami, nad drugą poplątana linia zalicza każdy punkt i wystrzeliwuje daleko poza kadr." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="skąd-bierze-się-ta-różnica">Skąd bierze się ta różnica</h2>
<p>Każdy zapis w zeszycie składa się z dwóch rzeczy: prawidłowości (cieplej, więc więcej lodów) i przypadku (akurat przyjechała wycieczka). Reguła ma uchwycić pierwszą, a drugą pominąć. Model nie wie jednak, co jest czym. Widzi tylko punkty.</p>
<p>O tym, ile przypadku model wchłonie, decyduje jego giętkość, w literaturze nazywana <strong>capacity</strong>: zdolność dopasowania się do wielu różnych kształtów. Krzywą w przykładzie opisuje od 2 do 10 liczb, które dobiera się do danych; ich liczba to stopień krzywej plus jeden. Krzywa stopnia 9 ma 10 takich liczb na 10 dni, więc potrafi trafić w każdy punkt, razem z całym przypadkiem. Autorzy podręcznika opisują to tak: bardzo giętki model może przedstawić właściwą zależność, ale także mnóstwo innych, równie dobrze pasujących do danych uczących, i mała jest szansa, że wybierze akurat tę, która sprawdzi się dalej (§5.2).</p>
<p>Typowy przebieg jest następujący: gdy giętkość rośnie, błąd na danych uczących maleje, a błąd na nowych danych najpierw maleje, potem zaczyna rosnąć (§5.2, rysunek 5.3). Wynika z tego praktyczna zasada. Modelu nie ocenia się na danych, na których się uczył, a giętkości nie dobiera się według błędu na tych danych, bo ten zawsze wskaże największą. Część danych odkłada się na bok: <strong><a href="https://paweldubiel.com/glossary/validation-set">validation set</a></strong> służy do wyboru ustawień, a osobny <strong>test set</strong> do końcowej oceny (§5.3).</p>
<h2 id="sprawdź-sam">Sprawdź sam</h2>
<p>Poniżej jest ta sama budka. Wszystkie liczby z tej notatki można odtworzyć: po kliknięciu „Od początku” widać 10 dni, a eksperymenty 1–5 ustawiają opisane przypadki.</p>
<div id="overfitting-lab"></div>
<p>Warto zrobić dwie rzeczy, których nie pokazuje statyczny wykres. Po pierwsze, włącz „24 inne zeszyty” i zmieniaj stopień: przy niskim szare linie trzymają się blisko siebie, przy wysokim rozchodzą się na wszystkie strony, choć każda pochodzi z tej samej budki. Po drugie, przeciągnij jeden punkt wysoko w górę. Krzywa stopnia 2 przesunie się tylko trochę, a krzywa stopnia 9 przebuduje się na całej długości, żeby w niego trafić.</p>
<h2 id="co-pomaga">Co pomaga</h2>
<ul>
<li><strong>Więcej danych.</strong> Przy 80 dniach ta sama krzywa stopnia 9 myli się typowo o 14,8 gałki na zeszycie i o 15,9 na nowych dniach. Różnica prawie znika, bo krzywa nie może już trafić w każdy punkt (§5.2).</li>
<li><strong>Mniejsza giętkość.</strong> Krzywa stopnia 3 na 10 dniach: 10,9 na zeszycie, 16,8 na nowych dniach.</li>
<li><strong>Regularization</strong>, czyli zmiana sposobu uczenia, która ma zmniejszyć błąd na nowych danych, a nie na uczących (§5.2.2). Przykładem jest kara za duże współczynniki, spokrewniona z <a href="https://paweldubiel.com/glossary/weight-decay">Weight decay</a>: krzywa stopnia 9 z karą λ = 0,01 myli się o 5,8 na zeszycie i o 21,2 na nowych dniach, zamiast o 236,5.</li>
</ul>
<p>Żadnego z tych ustawień nie da się wybrać, patrząc tylko na błąd na danych uczących.</p>
<h2 id="ograniczenia">Ograniczenia</h2>
<ul>
<li>To własny przykład z jedną wielkością wejściową i symulowanymi danymi. Sam przypadek daje tu typowo 15 gałek błędu i żadna reguła nie zejdzie niżej na nowych dniach.</li>
<li>Kształt „najpierw lepiej, potem gorzej” jest typowy, a nie gwarantowany. Autorzy zaznaczają, że w głębokich sieciach trudno nawet ustalić faktyczną giętkość modelu, bo zależy ona też od algorytmu uczenia (§5.2). Liczba parametrów LLM nie mówi więc sama, czy model jest przeuczony.</li>
<li>Mały błąd na nowych danych dotyczy danych z tego samego źródła. Jeśli budka przeniesie się nad morze, zeszyt z miasta niczego nie obiecuje.</li>
</ul>
<h2 id="powiązania">Powiązania</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/weight-decay">Weight decay</a> ogranicza wielkość wag i jest jednym ze sposobów na zmniejszenie różnicy między błędem na danych uczących i nowych.</li>
<li><a href="https://paweldubiel.com/glossary/grokking">Grokking</a> opisuje przypadki, w których model wyglądający na przeuczony po długim dalszym treningu zaczyna dobrze działać na nowych danych.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> na małym zbiorze wymaga tej samej kontroli: osobnych danych, których model nie widział podczas nauki.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting">Catastrophic Forgetting</a> to inny problem: tam model traci dawną umiejętność po nowej nauce, a tu od początku słabo przenosi się poza własne dane uczące.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Time horizon</title>
  <link>https://paweldubiel.com/glossary/time-horizon</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/time-horizon</guid>
  <pubDate>Sun, 11 Oct 2026 15:02:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Time horizon w ewaluacji agentów opisuje długość zadań, przy której agent osiąga wybrany poziom skuteczności. Długość mierzy się czasem potrzebnym człowiekowi, a nie czasem działania AI.</description>
  <content:encoded><![CDATA[<p><strong>Time horizon</strong> w ewaluacji agentów opisuje długość zadań, przy której agent osiąga wybrany poziom skuteczności. Długość mierzy się czasem potrzebnym człowiekowi, a nie czasem działania AI.</p>
<p>Dla wariantu 50% zbieramy udane i nieudane próby agenta na zadaniach o różnych czasach człowieka. Dopasowujemy krzywą szans sukcesu, a następnie odczytujemy czas, przy którym przecina ona 50%. To przewidywanie dla rozkładu zadań o danym czasie; nie oznacza, że każde z nich ma taką samą szansę wykonania. <a href="https://metr.org/time-horizons/" rel="noopener noreferrer">METR: definicja i metodologia</a>.</p>
<p>Przykład dydaktyczny: jeżeli dopasowana krzywa osiąga 50% przy dwóch godzinach, to dwie godziny są horyzontem. Agent może wykonać udane zadanie znacznie szybciej. Wynik sam nie określa też, z jaką skutecznością zrobi zadanie z innej dziedziny.</p>
<p>Odczyt wymaga sensownej zależności między czasem człowieka a trudnością dla AI. Gdy krzywa jest płaska, mała zmiana szans może bardzo przesunąć jej przecięcie z progiem. <a href="https://paweldubiel.com/articles/dluzszy-horyzont-metr-nie-oznacza-proporcjonalnie-trudniejszych-zadan">Artykuł o przeliczaniu horyzontu METR</a> pokazuje ten problem na policzalnym przykładzie i omawia nowe dopasowanie do danych METR. <a href="https://arxiv.org/html/2610.12466v1#S2" rel="noopener noreferrer">Nguyen i Fithian, §2–3</a>.</p>
<p>Przy porównywaniu horyzontów trzeba zachować informację o zestawie zadań, środowisku agenta, budżecie prób i przyjętym progu skuteczności.</p>]]></content:encoded>
</item>
<item>
  <title>Item response theory</title>
  <link>https://paweldubiel.com/glossary/item-response-theory</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/item-response-theory</guid>
  <pubDate>Sun, 11 Oct 2026 15:01:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Item response theory (IRT) to rodzina metod, które z odpowiedzi na poszczególne zadania wspólnie szacują możliwości wykonawców i trudność zadań.</description>
  <content:encoded><![CDATA[<p><strong>Item response theory (IRT)</strong> to rodzina metod, które z odpowiedzi na poszczególne zadania wspólnie szacują możliwości wykonawców i trudność zadań. W ewaluacji AI wykonawcą jest agent, a odpowiedzią może być sukces albo porażka pełnej próby.</p>
<p>Załóżmy, że dwóch agentów rozwiązuje te same trzy zadania. Pierwszy zwykle radzi sobie z A i B, drugi także z C. Sam procent sukcesów daje ranking. IRT próbuje dodatkowo oszacować, jak trudne jest C względem pozostałych zadań i jaka różnica możliwości wyjaśnia wzorzec odpowiedzi. To przykład dydaktyczny; tak mała tabela nie wystarcza do wiarygodnego dopasowania.</p>
<p>W prostym modelu Rascha szansa sukcesu rośnie, gdy możliwości agenta są większe względem trudności zadania. Obie wielkości są ukryte: wnioskujemy o nich z wyników, zamiast od razu utożsamiać trudność z długością instrukcji albo czasem człowieka. Różne warianty IRT dodają kolejne parametry i założenia.</p>
<p>W <a href="https://paweldubiel.com/articles/dluzszy-horyzont-metr-nie-oznacza-proporcjonalnie-trudniejszych-zadan">analizie horyzontów METR</a> autorzy wiążą ukrytą trudność z czasem pracy człowieka za pomocą uczonej krzywej. Dodają efekty rodzin zadań i zróżnicowanie wyników powtórek. Pozwala to sprawdzić, w którym zakresie czas rzeczywiście rozróżnia zadania trudne i łatwe dla AI. <a href="https://arxiv.org/html/2610.12466v1#S2.SS3" rel="noopener noreferrer">Nguyen i Fithian, §2.3 i §3.1</a>.</p>
<p>Dobre przewidywanie odpowiedzi nie dowodzi, że wyuczony parametr obejmuje wszystkie rodzaje możliwości agenta. Przy interpretacji trzeba sprawdzać założenia modelu i wyniki na zadaniach niewykorzystanych podczas dopasowania.</p>]]></content:encoded>
</item>
<item>
  <title>Elastic Weight Consolidation</title>
  <link>https://paweldubiel.com/glossary/elastic-weight-consolidation</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/elastic-weight-consolidation</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Model kieruje pytania klientów do działów „dostawa” i „zwroty”. Teraz ma się nauczyć rozpoznawania reklamacji, ale dawnych wiadomości nie wolno już przechowywać.</description>
  <content:encoded><![CDATA[<p>Model kieruje pytania klientów do działów „dostawa” i „zwroty”. Teraz ma się nauczyć rozpoznawania reklamacji, ale dawnych wiadomości nie wolno już przechowywać. Nie da się więc ich powtarzać podczas nauki. Jedyne, co zostało po starym zadaniu, to sam model: miliony liczb ustawionych w trakcie wcześniejszego uczenia, nazywanych wagami.</p>
<p>Można uczyć model reklamacji bez żadnych ograniczeń. Wtedy wagi przesuwają się tam, gdzie pomaga to nowemu zadaniu, również te, od których zależało rozpoznawanie dostawy i zwrotów. Można też ukarać każdą zmianę jednakowo, ale wtedy model trzyma się starych ustawień tak mocno, że słabo uczy się nowego. Potrzebna jest odpowiedź na pytanie: <strong>które wagi wolno ruszać, a których lepiej nie?</strong></p>
<p><strong>Elastic Weight Consolidation (EWC)</strong> dodaje do nauki nowego zadania karę za oddalanie się wag od wartości po starym zadaniu, przy czym kara jest tym większa, im ważniejsza była dana waga dla starego zadania. Autorzy porównują to do sprężyny przypiętej do każdej wagi: sztywnej przy wagach ważnych, luźnej przy pozostałych (<a href="https://arxiv.org/abs/1612.00796" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §2</a>).</p>
<p><img src="https://paweldubiel.com/assets/elastic-weight-consolidation-stiff-and-loose-springs.webp" alt="Rząd krążków przypiętych sprężynami do słupków: krążki na grubych, sztywnych sprężynach zostają na miejscu, a te na cienkich i luźnych przesuwają się w stronę czerwonego koła." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="dwie-wagi-jedno-nowe-zadanie">Dwie wagi, jedno nowe zadanie</h2>
<p>Weźmy tylko dwie wagi. Po nauce dostawy i zwrotów obie mają wartość 1. Pierwsza jest dla starych działów bardzo ważna (ważność 10), druga prawie obojętna (ważność 0,1). Nowe zadanie wymaga jedynie, żeby <strong>suma obu wag wyniosła 4</strong>. Spełnia to wiele ustawień: (2, 2), ale też (1, 3).</p>
<ul>
<li><strong>Bez ochrony</strong> nauka przesuwa obie wagi po równo, do (2, 2). Nowe zadanie jest opanowane, ale ważna waga odjechała o 1 i strata na starym zadaniu rośnie od 0 do 5,05.</li>
<li><strong>Jednakowa kara</strong> dla obu wag zatrzymuje je w pół drogi, przy (1,67, 1,67). Stare zadanie cierpi mniej, ale suma to 3,33 zamiast 4.</li>
<li><strong>EWC</strong> przenosi prawie cały ruch na mało ważną wagę: (1,02, 2,80). Suma wynosi 3,82, a strata na starym zadaniu to tylko 0,16.</li>
</ul>
<p>Strata to liczba mówiąca, jak bardzo model się myli; im mniejsza, tym lepiej. W eksperymencie poniżej możesz zmieniać siłę kary λ i sposób ochrony. Wynik jest liczony dokładnie dla tego dwuwagowego przykładu; to nie symulacja prawdziwej sieci.</p>
<div id="ewc-spring-lab"></div>
<h2 id="skąd-wiadomo-która-waga-jest-ważna">Skąd wiadomo, która waga jest ważna</h2>
<p>W prawdziwej sieci nikt nie podaje ważności z góry. Szacuje się ją po zakończeniu starego zadania, dopóki jego dane są jeszcze dostępne: sprawdza się, jak mocno drobna zmiana danej wagi zmienia odpowiedzi modelu na starych przykładach. Praca używa do tego przekątnej <em>macierzy informacji Fishera</em>, czyli jednej liczby ważności na każdą wagę. Potem dane można usunąć; zostają stare wartości wag i ich ważności.</p>
<p>Podczas nowej nauki minimalizowana jest suma dwóch składników (równanie 3 w pracy):</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>L</mi><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>L</mi><mi>B</mi></msub><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>+</mo><munder><mo>∑</mo><mi>i</mi></munder><mfrac><mi>λ</mi><mn>2</mn></mfrac><msub><mi>F</mi><mi>i</mi></msub><mtext> </mtext><mo stretchy="false">(</mo><msub><mi>θ</mi><mi>i</mi></msub><mo>−</mo><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L(\theta) = L_B(\theta) + \sum_i \frac{\lambda}{2} F_i \,(\theta_i - \theta^*_{A,i})^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">L</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.6491em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3714em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">λ</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.2472em;vertical-align:-0.3831em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7387em;"><span style="top:-2.453em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3831em;"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">L_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> to strata na nowym zadaniu, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">\theta_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> to bieżąca wartość wagi numer <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup></mrow><annotation encoding="application/x-tex">\theta^*_{A,i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1059em;vertical-align:-0.4114em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6887em;"><span style="top:-2.4247em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4114em;"><span></span></span></span></span></span></span></span></span></span> jej wartość po starym zadaniu, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">F_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> jej ważność, a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> mówi, jak bardzo stare zadanie liczy się wobec nowego. W naszym przykładzie <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><mn>10</mn><mo separator="true">;</mo><mtext> </mtext><mn>0,1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F = (10;\ 0{,}1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">10</span><span class="mpunct">;</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lambda = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<h2 id="granice-metody">Granice metody</h2>
<p>Ważność jest przybliżeniem liczonym w jednym punkcie, osobno dla każdej wagi. Sami autorzy pokazują, że ich oszacowanie bywa zbyt pewne co do tego, które wagi są nieistotne, i nazywają to główną słabością metody (§2.2 i §3). W ich eksperymentach z grami Atari agent z EWC uczył się wielu gier po kolei, ale nie dorównał osobnym sieciom uczonym dla każdej gry. Wyniki dotyczą rozpoznawania cyfr i gier, nie dużych modeli językowych. Nasze dwie wagi i wiadomości od klientów są własnym uproszczeniem.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting">Catastrophic Forgetting</a> to znaczne pogorszenie dawnych umiejętności po nowej nauce; EWC próbuje je ograniczyć bez dostępu do starych danych.</li>
<li><a href="https://paweldubiel.com/glossary/experience-replay">Experience Replay</a> rozwiązuje ten sam problem inaczej: przechowuje część dawnych przykładów zamiast ważności wag.</li>
<li><a href="https://paweldubiel.com/glossary/continual-learning">Continual Learning</a> określa cel, czyli naukę kolejnych zadań z zachowaniem wcześniejszych; EWC jest jedną z metod.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> to dalsze uczenie gotowego modelu; EWC zmienia jego cel, dodając karę za ruszanie ważnych wag.</li>
</ul>
<p><em>Tekst i ilustrację przygotowano z pomocą AI. Dwie wagi, ich ważności i demonstracja są własnym uproszczonym przykładem edukacyjnym; ilustracja jest metaforą, nie schematem budowy modelu.</em></p>]]></content:encoded>
</item>
<item>
  <title>Reservoir Sampling</title>
  <link>https://paweldubiel.com/glossary/reservoir-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/reservoir-sampling</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Model obsługi klienta uczy się na wiadomościach, które przychodzą jedna po drugiej. Chcesz zachować kilka z nich do późniejszych powtórek, ale masz tylko cztery miejsca w pamięci.</description>
  <content:encoded><![CDATA[<p>Model obsługi klienta uczy się na wiadomościach, które przychodzą jedna po drugiej. Chcesz zachować kilka z nich do późniejszych powtórek, ale masz tylko cztery miejsca w pamięci. Nie wiesz też, ile wiadomości jeszcze przyjdzie: dwadzieścia czy dwa miliony.</p>
<p>Zostawić pierwsze cztery? Wtedy pamięć zna tylko początek. Trzymać zawsze cztery ostatnie? Wtedy zna tylko koniec. Uczciwe losowanie „czterech z całości” wymagałoby przechowania wszystkiego albo znajomości liczby wiadomości z góry. Pytanie brzmi: <strong>jak przy stałej liczbie miejsc i nieznanej długości strumienia dać każdej wiadomości tę samą szansę?</strong></p>
<p><strong>Reservoir Sampling</strong> to sposób utrzymywania losowej próbki o stałej wielkości podczas jednego przejścia przez dane, których liczby nie znamy z góry. Po każdej kolejnej wiadomości pamięć, nazywana tu rezerwuarem, zawiera uczciwą losową próbkę wszystkiego, co do tej pory przyszło. Najprostszą wersję, Algorithm R, opisuje <a href="https://doi.org/10.1145/3147.3165" rel="noopener noreferrer">Vitter, <em>Random Sampling with a Reservoir</em>, §2</a>, przypisując ją Alanowi Watermanowi.</p>
<p><img src="https://paweldubiel.com/assets/reservoir-sampling-pebble-stream-four-slot-tray.webp" alt="Długi strumień kamyków i muszli płynie obok małej drewnianej tacki z czterema wgłębieniami; jedna ręka wyjmuje kamyk z tacki, druga wkłada na jego miejsce kamyk ze strumienia." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="przepis-w-dwóch-krokach">Przepis w dwóch krokach</h2>
<ol>
<li>Pierwsze cztery wiadomości trafiają do pamięci bez losowania.</li>
<li>Wiadomość numer <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> (piąta, szósta i każda następna) dostaje się do pamięci z szansą <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>. Jeśli się dostała, zastępuje jedną z czterech zapisanych, wybraną losowo.</li>
</ol>
<p>Piąta wiadomość wchodzi więc z szansą 4/5, setna z szansą 4/100. Nowe wiadomości mają coraz mniejszą szansę wejścia, ale stare były już wielokrotnie narażone na wyrzucenie, i te dwa efekty dokładnie się równoważą. Sprawdźmy to po piątej wiadomości. Wchodzi z szansą 4/5. Pierwsza wiadomość wypada tylko wtedy, gdy piąta weszła (4/5) i trafiła akurat na jej miejsce (1/4), czyli z szansą 1/5. Zostaje z szansą 4/5: taką samą, jaką ma piąta. Po <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> wiadomościach każda z nich jest w pamięci z szansą <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>.</p>
<h2 id="równa-szansa-to-nie-gwarancja">Równa szansa to nie gwarancja</h2>
<p>W eksperymencie strumień ma 20 wiadomości. Osiemnaście dotyczy dostawy, a dwie, dziewiąta i piętnasta, dotyczą zwrotów. Każde uruchomienie przepuszcza taki strumień 2000 razy i liczy, jak często dana pozycja została w pamięci na końcu. Losowania są prawdziwe, więc wyniki za każdym razem różnią się o ułamek procenta.</p>
<div id="reservoir-sampling-lab"></div>
<p>Przy Reservoir Sampling każdy słupek ma około 20%, czyli 4/20. Jednocześnie w większości przebiegów żaden z dwóch zwrotów nie zostaje w pamięci. Dokładna wartość to 3060/4845, czyli około 63%: tyle spośród wszystkich czwórek wybranych z 20 wiadomości składa się wyłącznie z osiemnastu wiadomości o dostawie. Metoda jest uczciwa wobec pojedynczych wiadomości, ale nie pilnuje, żeby każda kategoria miała przedstawiciela.</p>
<h2 id="gdzie-to-ma-znaczenie">Gdzie to ma znaczenie</h2>
<p>W uczeniu z powtórkami Reservoir Sampling bywa sposobem zapisu do bufora: nie trzeba znać długości strumienia ani granic między zadaniami. <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algorytm 2</a> używają go właśnie tak. W ich eksperymentach na zadaniach obrazowych sprawdzał się dobrze, z wyjątkiem bardzo małych pamięci, gdzie z bufora znikały wcześniejsze klasy; lepiej wypadały wtedy strategie dbające o równą reprezentację klas (§4.4). To wynik dla klasyfikacji obrazów, nie dla LLM.</p>
<p>Sam algorytm nie dotyczy uczenia maszynowego. Praca Vittera z 1985 roku opisuje losowanie rekordów z taśmy magnetycznej o nieznanej długości i proponuje szybsze warianty, które zamiast losować przy każdym rekordzie wyliczają, ile rekordów pominąć. Wiadomości od klientów i strumień 20 pozycji są własnym przykładem.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/experience-replay">Experience Replay</a> potrzebuje bufora z dawnymi przykładami; Reservoir Sampling jest jednym ze sposobów decydowania, co do niego trafia.</li>
<li><a href="https://paweldubiel.com/glossary/continual-learning">Continual Learning</a> zakłada naukę ze strumienia danych przy ograniczonej pamięci, czyli sytuację, w której nie da się zachować wszystkiego.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting">Catastrophic Forgetting</a> może się nasilić, gdy z małej pamięci wypadną wszystkie przykłady dawnej kategorii.</li>
</ul>
<p><em>Tekst i ilustrację przygotowano z pomocą AI. Strumień wiadomości i demonstracja są własnym uproszczonym przykładem edukacyjnym; ilustracja jest metaforą, nie schematem algorytmu.</em></p>]]></content:encoded>
</item>
<item>
  <title>Experience Replay</title>
  <link>https://paweldubiel.com/glossary/experience-replay</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/experience-replay</guid>
  <pubDate>Sun, 11 Oct 2026 08:22:26 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Model nauczył się kierować pytania klientów do działów „dostawa” i „zwroty”. Teraz douczasz go rozpoznawania reklamacji, na przykład „Produkt dotarł uszkodzony”.</description>
  <content:encoded><![CDATA[<p>Model nauczył się kierować pytania klientów do działów „dostawa” i „zwroty”. Teraz douczasz go rozpoznawania reklamacji, na przykład „Produkt dotarł uszkodzony”. Jeśli w kolejnych ćwiczeniach widzi wyłącznie reklamacje, może gorzej obsługiwać dawniej znane „Gdzie jest paczka?”. Pełne stare archiwum jest niedostępne. Czy można wracać choć do kilku zachowanych wiadomości?</p>
<p><strong>Experience Replay (ER)</strong> polega na przechowywaniu części wcześniejszych przykładów i ponownym używaniu ich do uczenia. W prostym wariancie do porcji nowych danych domieszamy przykłady z pamięci, nazywanej <em>replay buffer</em>. To pojemnik na dane do powtórek, nie zapis całej wiedzy modelu. Takie wspólne uczenie opisują <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, algorytm 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/experience-replay-card-box-returning-examples.webp" alt="Zachowane granatowe i ochrowe karty wracają z niewielkiej kasety do szeregu nowych czerwonych kart: metafora powtórek podczas dalszej nauki." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-trafia-do-kolejnego-ćwiczenia">Co trafia do kolejnego ćwiczenia</h2>
<p>Przed utratą archiwum zapisaliśmy cztery wiadomości wraz z poprawnymi działami. Teraz mamy cztery nowe reklamacje. Bez powtórek model uczy się na czterech nowych wiadomościach. Z powtórkami ćwiczy również na czterech dawnych: otrzymuje ponownie sygnał, że „Gdzie jest paczka?” należy do dostawy. W tym małym przykładzie wykorzystujemy cały bufor; większe bufory zwykle dostarczają losowaną porcję.</p>
<p>Nie wystarczy jednak policzyć miejsc w pamięci. Cztery zapisane pytania o dostawę nie zawierają ani jednego przykładu zwrotu. Po zamianie dwóch z nich na „Jak odesłać zakup?” i „Chcę zwrócić koszulę” liczba powtórek pozostaje taka sama, ale obejmuje oba wcześniejsze działy. Poniższy eksperyment <strong>liczy przykłady w porcji danych; nie przewiduje trafności modelu</strong>.</p>
<div id="experience-replay-lab"></div>
<h2 id="powtórki-pomagają-tylko-na-dostępnych-danych">Powtórki pomagają tylko na dostępnych danych</h2>
<p>Model dostaje okazję ćwiczenia wcześniejszych odpowiedzi, lecz nie gwarancję zachowania wszystkich umiejętności. Losowa mała próbka może całkiem pominąć rzadką kategorię; taki problem badacze obserwowali przy bardzo małych buforach (§4.4 tej samej pracy). Nasze wiadomości są własnym przykładem, nie wynikiem tych eksperymentów. Skutek nauki trzeba sprawdzić na osobnych starych i nowych wiadomościach, nieużywanych do treningu. Bufor zajmuje też pamięć i wymaga zachowania wybranych danych.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/reservoir-sampling">Reservoir Sampling</a> — sposób decydowania, które przykłady ze strumienia trafiają do bufora o stałej wielkości, dający każdemu równą szansę.</p>
<p>W grach, w <a href="https://paweldubiel.com/glossary/reinforcement-learning">Reinforcement Learning</a> — uczeniu działań na podstawie nagród — zachowuje się sytuację, działanie, nagrodę i następną sytuację. Losowanie takich zapisów ogranicza zależność od bezpośrednio następujących po sobie zdarzeń (<a href="https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf#page=7" rel="noopener noreferrer">Mnih et al., <em>Human-level control through deep reinforcement learning</em>, Methods, „Training algorithm for deep Q-networks”</a>). To inne dane niż wiadomość z poprawnym działem; wyników z Atari nie należy przenosić wprost na LLM.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/continual-learning">Continual Learning</a> określa cel dalszej nauki z zachowaniem wcześniejszych zdolności; ER jest jednym ze sposobów jego realizacji.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting">Catastrophic Forgetting</a> opisuje znaczne pogorszenie dawnych umiejętności, które powtórki mogą ograniczać.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> jest dalszym uczeniem modelu; replay zmienia dobór jego danych. Samo wklejenie dawnych wiadomości do rozmowy nie jest taką aktualizacją modelu.</li>
</ul>
<p><em>Tekst i ilustrację przygotowano z pomocą AI. Wiadomości i demonstracja są własnym uproszczonym przykładem edukacyjnym; ilustracja jest metaforą, nie schematem budowy modelu.</em></p>]]></content:encoded>
</item>
<item>
  <title>Continual Learning</title>
  <link>https://paweldubiel.com/glossary/continual-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/continual-learning</guid>
  <pubDate>Sat, 10 Oct 2026 20:03:52 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Model kieruje wiadomości klientów do działów „zamówienia” i „zwroty”. Potrafi rozpoznać „Gdzie jest moja paczka?”. Teraz firma otwiera dział reklamacji.</description>
  <content:encoded><![CDATA[<p>Model kieruje wiadomości klientów do działów „zamówienia” i „zwroty”. Potrafi rozpoznać „Gdzie jest moja paczka?”. Teraz firma otwiera dział reklamacji. Douczasz model na wiadomościach o uszkodzonych produktach. Reklamacje trafiają coraz lepiej, ale część pytań o dostawę też zaczyna lądować w nowym dziale. Sprawdzenie samych reklamacji dałoby fałszywe poczucie postępu.</p>
<p>Potrzebujesz <strong>uczyć model kolejnych rzeczy, zachowując wcześniejsze umiejętności</strong>. To cel <strong>Continual Learning</strong>: uczenia na napływających kolejno danych lub zadaniach, z uwzględnieniem tego, czego model nauczył się wcześniej. Nazwa określa problem i rodzinę podejść; nie gwarantuje braku zapominania. Taką potrzebę opisują <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a>.</p>
<p><img src="https://paweldubiel.com/assets/continual-learning-embroidered-sampler-growing-repertoire.webp" alt="Na jednym kawałku tkaniny pozostają wyhaftowane okręgi i trójkąty, a igła dopisuje nowy falisty wzór: metafora rozwijania umiejętności z zachowaniem wcześniejszych." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-zmieniamy-w-nauce-i-sprawdzaniu">Co zmieniamy w nauce i sprawdzaniu</h2>
<p>Załóżmy, że pełne archiwum przykładów użytych do wcześniejszego uczenia nie jest już dostępne. Przed jego usunięciem zachowaliśmy małą próbkę: 20 wiadomości ze znanymi poprawnymi działami. Jedna z możliwych metod polega na domieszaniu tej próbki do nowych przykładów reklamacji. Dzięki temu dalsze uczenie otrzymuje również sygnał, by nadal poprawnie obsługiwać „Gdzie jest moja paczka?”. Ponowne użycie dawnych przykładów jest jedną ze strategii opisanych przez <a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Vena i Toliasa, <em>Three scenarios for continual learning</em>, §3.3</a>.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/experience-replay">Experience Replay</a> — przechowywanie niewielkiej próbki dawnych przykładów i domieszanie jej do nowej nauki.</p>
<p>Zespół oceniający zachowuje osobny test starych wiadomości, którego <strong>nie używamy do uczenia</strong>. Po każdej aktualizacji sprawdzamy stare i nowe kategorie. Poniższe liczby są wymyślonym przykładem, nie wynikiem badania; każdy test zawiera 100 wiadomości.</p>

























<table><thead><tr><th>Wariant modelu</th><th>Poprawne stare wiadomości</th><th>Poprawne reklamacje</th></tr></thead><tbody><tr><td>Przed nową nauką</td><td>90/100</td><td>0/100 — brak tej kategorii</td></tr><tr><td>Po nauce wyłącznie reklamacji</td><td>40/100</td><td>92/100</td></tr><tr><td>Po nauce z próbką dawnych wiadomości</td><td>89/100</td><td>87/100</td></tr></tbody></table>
<p>Ostatni wariant lepiej zachowuje wcześniejszą umiejętność, choć słabiej rozpoznaje reklamacje niż drugi. Tabela pokazuje, <strong>co porównywać</strong>; nie obiecuje takiego wyniku po dodaniu 20 przykładów.</p>
<h2 id="warunki-zmieniają-trudność">Warunki zmieniają trudność</h2>
<p>W naszym przykładzie model sam wybiera spośród wszystkich poznanych działów. Podpowiedź „to wiadomość z nowej kategorii” ułatwiałaby test. Dostępność takich podpowiedzi i granic między zadaniami jest ważna przy porównywaniu metod (<a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven i Tolias, §2–2.3</a>). Mała próbka może pominąć rzadkie pytania; dobra średnia nie dowodzi zachowania każdej umiejętności.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting">Catastrophic Forgetting</a> opisuje znaczne pogorszenie starych umiejętności; jego demonstracja pokazuje, jak nowa nauka zmienia wspólne ustawienia.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> to dalsze uczenie modelu na wybranych przykładach. Po kolejnych treningach sprawdzamy również wcześniejsze zdolności.</li>
<li><a href="https://paweldubiel.com/glossary/knowledge-distillation">Knowledge Distillation</a> może przekazywać wskazówki ze starszego modelu do aktualizowanego; to inna strategia niż przechowanie oryginalnych wiadomości (§3.3 pracy van de Vena i Toliasa).</li>
</ul>
<p><em>Tekst i ilustrację przygotowano z pomocą AI; wiadomości, wielkość próbki i wyniki tabeli są własnym przykładem edukacyjnym. Ilustracja pokazuje cel zachowania wcześniejszych umiejętności, nie budowę modelu.</em></p>]]></content:encoded>
</item>
<item>
  <title>Learning Rate Warmup</title>
  <link>https://paweldubiel.com/glossary/learning-rate-warmup</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/learning-rate-warmup</guid>
  <pubDate>Sat, 10 Oct 2026 09:30:03 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz nauczyć prosty model przewidywania czasu dostawy. W naszym wymyślonym przykładzie każda dostawa trwa 10 minut, a model zaczyna od prognozy 0. Trzeba przesunąć ją w górę.</description>
  <content:encoded><![CDATA[<p>Chcesz nauczyć prosty model przewidywania czasu dostawy. W naszym wymyślonym przykładzie każda dostawa trwa 10 minut, a model zaczyna od prognozy 0. Trzeba przesunąć ją w górę. Sama właściwa wskazówka kierunku nie wystarcza: zbyt duża poprawka może przeskoczyć cel i pogorszyć wynik. Chcesz ograniczyć początkowe zmiany, a później dopuścić większe.</p>
<p><strong>Learning Rate Warmup</strong> to początkowy etap uczenia, w którym stopniowo zwiększamy <strong>learning rate</strong>, czyli współczynnik regulujący wielkość aktualizacji ustawień modelu. Określamy docelową wartość i liczbę kroków dojścia do niej. Nie chodzi o nagrzewanie komputera. Liniowy wariant opisują <a href="https://proceedings.mlr.press/v119/xiong20b/xiong20b.pdf#page=3" rel="noopener noreferrer">Xiong i współautorzy, §3.2, równanie 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/learning-rate-warmup-four-step-ramp-plateau.webp" alt="Czerwona papierowa wstęga tworząca cztery stopnie i równy podest jako metafora wzrostu learning rate do ustalonej wartości." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="ten-sam-kierunek-inna-wielkość-poprawki">Ten sam kierunek, inna wielkość poprawki</h2>
<p>Model ma jedną <strong>wagę</strong> — regulowaną liczbę równą prognozie. <strong>Strata</strong> ocenia pomyłkę: przyjmujemy połowę kwadratu różnicy między prognozą a celem 10. <strong>Gradient</strong> mówi, jak mała zmiana wagi wpływa na tę stratę. Tutaj wynosi <code>prognoza − 10</code>. Odejmujemy gradient pomnożony przez learning rate, podobnie jak w <a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">SGD</a>; w tym przykładzie nie losujemy danych.</p>
<p>Na starcie gradient to <code>−10</code>. Przy learning rate <strong>2,4</strong> pierwsza poprawka daje <code>0 − 2,4 × (−10) = 24</code>. Błąd względem 10 rośnie z 10 do 14 minut. Przy czterech krokach liniowego warmup zaczynamy od jednej czwartej docelowej wartości, czyli <strong>0,6</strong>. Prognoza zmienia się na <strong>6</strong>, a błąd maleje do 4 minut. Następne wartości learning rate to <strong>1,2; 1,8; 2,4</strong>. Gradient obliczamy od nowa przed każdą poprawką.</p>
<p>Warmup łagodzi więc start, lecz <strong>nie naprawia zbyt dużej wartości docelowej</strong>. W tym przykładzie po dojściu do 2,4 pomyłki znów narastają. Przy rozsądnym 0,8 wariant bez warmup od początku zbliża się do celu szybciej. To ograniczenie zobaczysz poniżej.</p>
<h2 id="sprawdź-pierwszy-krok-i-dalszy-ciąg">Sprawdź pierwszy krok i dalszy ciąg</h2>
<p>Porównaj pierwszy krok, potem wykonaj dwanaście. Zmień docelową wartość z 2,4 na 0,8. Oba przebiegi startują od zera i widzą te same dane. Słupki pokazują <strong>learning rate</strong>, a nie rzeczywistą odległość przesunięcia wagi: ta zależy także od gradientu.</p>
<div id="learning-rate-warmup-lab"></div>
<h2 id="dlaczego-przydaje-się-w-modelach-językowych">Dlaczego przydaje się w modelach językowych?</h2>
<p>W oryginalnym <a href="https://paweldubiel.com/glossary/transformer">Transformerze</a> <a href="https://arxiv.org/html/1706.03762v7#S5.SS3" rel="noopener noreferrer">Vaswani i współautorzy, §5.3</a>, zwiększali learning rate liniowo przez <strong>4000 kroków</strong>, a później go zmniejszali. Używali <a href="https://paweldubiel.com/glossary/adam">Adama</a>, czyli algorytmu dobierającego aktualizacje na podstawie historii gradientów. Warmup określa harmonogram jego learning rate, a nie zastępuje optymalizatora.</p>
<p>Xiong i współautorzy wiążą trudny start m.in. z dużymi początkowymi gradientami w badanej architekturze (<a href="https://proceedings.mlr.press/v119/xiong20b/xiong20b.pdf#page=5" rel="noopener noreferrer">§3.3–3.4</a>). Przesunięcie <a href="https://paweldubiel.com/glossary/layer-normalization">Layer Normalization</a> — operacji regulującej skalę liczb wewnątrz modelu — przed główne obliczenia danego bloku pozwoliło im uczyć wariant <strong>Pre-LN</strong> bez warmup (<a href="https://proceedings.mlr.press/v119/xiong20b/xiong20b.pdf#page=7" rel="noopener noreferrer">§4</a>). W oryginalnym wariancie <strong>Post-LN</strong> normalizacja następuje po dodaniu wyniku bloku do jego wejścia. Nie wynika z tego, że każdy model potrzebuje warmup ani że każdy Pre-LN może go pominąć.</p>
<p><a href="https://paweldubiel.com/glossary/gradient-clipping">Gradient Clipping</a> ogranicza wielkość gradientu; warmup zmienia współczynnik zastosowania aktualizacji w czasie. Nasza demonstracja pokazuje tylko ten drugi pomysł na jednej wadze. Utrzymuje stały learning rate po czterech krokach, aby odsłonić ograniczenie; nie odtwarza całej receptury treningu Transformera.</p>]]></content:encoded>
</item>
<item>
  <title>Catastrophic Forgetting</title>
  <link>https://paweldubiel.com/glossary/catastrophic-forgetting</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/catastrophic-forgetting</guid>
  <pubDate>Thu, 08 Oct 2026 10:04:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Wyobraź sobie model wyceny paczek. Umie już podać poprawną cenę małej paczki: 2 zł. Teraz uczysz go wyceniać dużą na 4 zł, pokazując wyłącznie duże paczki.</description>
  <content:encoded><![CDATA[<p>Wyobraź sobie model wyceny paczek. Umie już podać poprawną cenę małej paczki: <code>2 zł</code>. Teraz uczysz go wyceniać dużą na <code>4 zł</code>, pokazując wyłącznie duże paczki. Nowe odpowiedzi stają się coraz lepsze, ale mała paczka zaczyna kosztować według modelu <code>3 zł</code>. Sam test nowego zadania nie ujawni tej straty.</p>
<p><strong>Catastrophic Forgetting</strong> to znaczne pogorszenie wcześniej wyuczonych umiejętności podczas uczenia kolejnych zadań. Wagi, czyli liczby sterujące obliczeniami modelu, mogą służyć wielu zadaniom naraz. Poprawki korzystne dla nowego zadania mogą naruszyć ustawienia potrzebne do starego. Ten mechanizm opisują <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a>.</p>
<h2 id="dwie-ceny-korzystają-ze-wspólnego-ustawienia">Dwie ceny korzystają ze wspólnego ustawienia</h2>
<p>W naszym <strong>wymyślonym, celowo małym modelu</strong> mała paczka kosztuje <code>a</code>, a duża <code>a + b</code>. <code>a</code> i <code>b</code> są uczonymi liczbami, jak dwa pokrętła. Początkowo <code>a = 2</code>, <code>b = 0</code>: mała paczka jest wyceniona dobrze, duża zbyt tanio.</p>
<p>Uczenie dużych paczek zwiększa oba ustawienia. Po pierwszym kroku dostajemy <code>a = 2,5</code>, <code>b = 0,5</code>. Cena dużej rośnie z <code>2</code> do <code>3 zł</code>, bliżej celu. Cena małej też rośnie — mimo że nie miała się zmienić. Po wielu krokach duża zbliża się do <code>4 zł</code>, a mała do błędnych <code>3 zł</code>.</p>
<p>Nie brakuje tu miejsca na obie umiejętności: <code>a = 2</code>, <code>b = 2</code> daje obie poprawne ceny. Problem polega na tym, <strong>które ustawienia zmienia dalsze uczenie</strong>. Gdy zachowamy <code>a = 2</code> i uczymy tylko <code>b</code>, możemy poprawić dużą paczkę bez psucia małej. To idealizowana ochrona przy znanej roli każdego ustawienia, a nie gotowa recepta dla ogromnego modelu językowego.</p>
<p><img src="https://paweldubiel.com/assets/catastrophic-forgetting-clay-tablet-overwritten-groove.webp" alt="Na jednej glinianej tabliczce nowy zygzak przecina i częściowo zaciera wcześniejszy okrągły wzór: metafora uczenia zmieniającego wspólne ustawienia." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-to-zmienia-przy-douczaniu-llm">Co to zmienia przy douczaniu LLM</h2>
<p><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> oznacza dalsze uczenie modelu na nowych przykładach. Wyobraź sobie model dobrze tłumaczący tekst, który douczasz wyłącznie pisania zapytań do bazy danych. Lepsze zapytania nie gwarantują zachowania jakości tłumaczeń. Trzeba sprawdzać oba zadania na tych samych zestawach testowych, nieużywanych do uczenia, przed i po treningu. To przykład zastosowania mechanizmu, nie wynik eksperymentu z paczkami.</p>
<p>W badaniu LLM pogorszenie wcześniejszych zdolności zaobserwowali <a href="https://arxiv.org/html/2308.08747v5#S5.SS1" rel="noopener noreferrer">Luo et al., §5.1</a>. Domieszanie ogólnych przykładów do nowej nauki ograniczało ten problem w ich eksperymentach (§5.4), lecz nie usuwało go całkowicie. Inną metodą jest <a href="https://paweldubiel.com/glossary/elastic-weight-consolidation">ostrożniejsze zmienianie wag ważnych dla starych zadań</a>, opisane przez Kirkpatrick et al. w §2. Zachowanie wcześniejszej wiedzy i swoboda nowej nauki wymagają kompromisu.</p>
<p>Nie każda pomyłka oznacza Catastrophic Forgetting. Potrzebne jest porównanie zachowania po zmianie wyuczonych ustawień. Jeśli informacja jedynie wypadła z tekstu dostępnego w rozmowie, to inny problem. Poniższy model pokazuje współdzielenie ustawień; nie mierzy skali zapominania w LLM ani nie dowodzi trwałego wymazania wiedzy.</p>
<h2 id="sprawdź-co-traci-stara-umiejętność">Sprawdź, co traci stara umiejętność</h2>
<p>Zwiększ liczbę kroków. Czy malejący błąd dużej paczki wystarczy, by uznać cały model za lepszy? Następnie zaznacz ochronę <code>a</code> i porównaj obie ceny przy tej samej liczbie kroków.</p>
<div id="catastrophic-forgetting-lab"></div>
<p><strong>Jak liczymy kroki:</strong> błąd uczenia dużej paczki to połowa kwadratu różnicy <code>a + b − 4</code>. Gradient — wskazówka, jak zmiana każdej liczby zmieni ten błąd — wynosi tutaj <code>a + b − 4</code> dla obu ustawień. W każdym kroku odejmujemy od zmienianych ustawień ćwierć tej wartości, obliczonej <strong>przed</strong> aktualizacją. To prosta reguła zejścia po gradiencie, pokrewna mechanizmowi <a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">Stochastic Gradient Descent</a>; używamy jednego stałego przykładu, bez losowania danych. Przy ochronie <code>a</code> zmieniamy tylko <code>b</code>.</p>
<h2 id="powiązania">Powiązania</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/pre-training">Pre-training</a> daje wcześniejsze umiejętności, które dalsze uczenie może naruszyć.</li>
<li><a href="https://paweldubiel.com/glossary/lora">LoRA</a> uczy dodatki do bazowego modelu; zachowanie bazowych wag samo w sobie nie dowodzi zachowania wcześniejszych umiejętności modelu z aktywnymi dodatkami.</li>
</ul>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/continual-learning">Continual Learning</a> — uczenie kolejnych zadań z zachowaniem wcześniejszych umiejętności.</p>
<p><em>Tekst, ilustrację i demonstrację przygotowano z pomocą AI; ceny i model dwóch liczb są własnym przykładem edukacyjnym.</em></p>]]></content:encoded>
</item>
<item>
  <title>Sequence Packing</title>
  <link>https://paweldubiel.com/glossary/sequence-packing</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/sequence-packing</guid>
  <pubDate>Wed, 07 Oct 2026 07:34:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Uczysz model pisać krótkie odpowiedzi klientom: „Dziękuję bardzo”, „Nie” i „Tak”. Po podziale na kawałki tekstu, czyli tokeny, przykłady mają umownie 3, 2 i 2 pozycje, wliczając znacznik końca…</description>
  <content:encoded><![CDATA[<p>Uczysz model pisać krótkie odpowiedzi klientom: „Dziękuję bardzo”, „Nie” i „Tak”. Po podziale na kawałki tekstu, czyli <a href="https://paweldubiel.com/glossary/token">tokeny</a>, przykłady mają umownie 3, 2 i 2 pozycje, wliczając znacznik końca każdego tekstu. Jeśli każdy zapisujesz w osobnym wierszu o ośmiu miejscach, z 24 miejsc tylko siedem zawiera dane. Reszta to <strong>padding</strong> — wypełnienie, które wyrównuje długości, lecz nie jest treścią do nauczenia. Jak wykorzystać wolne miejsca?</p>
<p><strong>Sequence Packing</strong> układa kilka przykładów w jednym ciągu wejściowym, aby ograniczyć wypełnienie podczas treningu. W naszym przykładzie wszystkie trzy mieszczą się w jednym ośmiopozycyjnym wierszu: siedem miejsc z danymi, jedno puste. Nie powstały nowe odpowiedzi; zmieniło się ich ułożenie. Taką rolę opisuje <a href="https://huggingface.co/docs/trl/v0.29.0/sft_trainer#packing" rel="noopener noreferrer">dokumentacja TRL 0.29.0, SFT Trainer, sekcja „Packing”</a>.</p>
<p><img src="https://paweldubiel.com/assets/sequence-packing-paper-strips-divided-tray.webp" alt="Trzy kolorowe paski papieru ciasno ułożone w jednej podłużnej tacce, z cienkimi przegrodami zachowującymi ich odrębność: metafora Sequence Packing." loading="eager" decoding="async" width="1536" height="1024"></p>
<p>Osiem miejsc to <strong>własne uproszczenie</strong>, nie domyślny rozmiar wiersza w TRL. Zwykła porcja przykładów może być wyrównana tylko do najdłuższego tekstu; grupowanie podobnych długości także zmniejsza straty miejsca. Już <a href="https://arxiv.org/html/1706.03762v7#S5.SS1" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §5.1</a>, opisuje takie grupowanie. Liczba pustych miejsc sama nie wyznacza przyspieszenia: zależy ono również od sposobu wykonywania obliczeń.</p>
<h2 id="wspólny-wiersz-nie-musi-oznaczać-wspólnej-rozmowy">Wspólny wiersz nie musi oznaczać wspólnej rozmowy</h2>
<p>Chcesz, żeby „Nie” pozostało niezależnym przykładem, a nie dalszym ciągiem „Dziękuję bardzo”. Sam znacznik końca jest tylko tokenem. Zwykła blokada podglądania przyszłości — <a href="https://paweldubiel.com/glossary/causal-masking">Causal Masking</a> — nadal pozwala późniejszemu tekstowi czytać wcześniejszy w tym samym wierszu.</p>
<p>Żeby zachować niezależność, obliczenia muszą znać granice przykładów i blokować dostęp przez te granice. Osobno trzeba dopilnować oceny błędu: nie uczyć przewidywania pierwszego tokena „Nie” z końca poprzedniego tekstu. Wybór ocenianych pozycji to <a href="https://paweldubiel.com/glossary/loss-masking">Loss masking</a>; pominięcie kary za pozycję <strong>nie blokuje jej czytania</strong>.</p>
<p>Konkretnie w <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/trainer/sft_trainer.py" rel="noopener noreferrer">kodzie TRL 0.29.0: DataCollatorForLanguageModeling i konfiguracji BFD packing</a> długości przykładów służą odtworzeniu granic, a początki są pomijane w ocenie błędu. Ten przebieg wymaga zgodnej implementacji attention — mechanizmu korzystania z innych pozycji tekstu; kod ostrzega przed przenikaniem informacji przy nieobsługiwanej konfiguracji. To warunek konkretnego rozwiązania, nie własność każdego packing.</p>
<h2 id="sprawdź-dwie-osobne-rzeczy">Sprawdź dwie osobne rzeczy</h2>
<p>Włącz pakowanie, a następnie wyłącz rozdzielenie dostępu. Miejsca pozostaną oszczędzone, ale B1 będzie mogło korzystać z wcześniejszego przykładu A. Kwadraty oznaczają tokeny końca; A1, B1 itd. to umowne kawałki tekstu. Demonstracja pokazuje dozwolone połączenia, bez symulowania odpowiedzi modelu. Wariant „pełne wiersze” ujawnia brak oszczędności, gdy wszystkie przykłady już wypełniają po osiem miejsc.</p>
<div id="sequence-packing-lab"></div>
<p>Strategie różnią się zachowaniem długich tekstów. W <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/data_utils.py" rel="noopener noreferrer">TRL 0.29.0, funkcja <code>pack_dataset</code></a>, <code>bfd</code> dopasowuje całe przykłady do wolnych miejsc, lecz obcina nadmiar zbyt długiego przykładu; <code>wrapped</code> może przeciąć tekst w środku. Dlatego trzeba sprawdzić zarówno zachowane dane, jak i granice. Packing porządkuje wejścia do uczenia, w tym <a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> — dalszego dostosowywania modelu na przykładach. Nie powiększa maksymalnej długości tekstu obsługiwanej przez model.</p>]]></content:encoded>
</item>
<item>
  <title>Direct Preference Optimization</title>
  <link>https://paweldubiel.com/glossary/direct-preference-optimization</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/direct-preference-optimization</guid>
  <pubDate>Tue, 06 Oct 2026 07:32:17 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Prosisz model: „Napisz krótką odmowę zaproszenia, bez podawania powodu”. Odpowiedź A brzmi: „Dziękuję za zaproszenie. Tym razem nie przyjdę”. B dopisuje: „Nie przyjdę, bo wyjeżdżam”.</description>
  <content:encoded><![CDATA[<p>Prosisz model: „Napisz krótką odmowę zaproszenia, bez podawania powodu”. Odpowiedź A brzmi: „Dziękuję za zaproszenie. Tym razem nie przyjdę”. B dopisuje: „Nie przyjdę, bo wyjeżdżam”. Wskazujesz A jako lepszą. Można douczać model, pokazując mu tylko A do naśladowania, ale wtedy odrzuca się część informacji: <strong>A była lepsza od konkretnej B</strong>. Jak wykorzystać całe porównanie, żeby zmienić sposób odpowiadania?</p>
<p><strong>Direct Preference Optimization (DPO)</strong> to metoda dalszego uczenia modelu językowego na parach odpowiedzi oznaczonych jako preferowana i odrzucona. Porównania bezpośrednio wyznaczają błąd, na podstawie którego zmienia się model generujący. Oryginalna metoda nie wymaga osobnego trenowania oceniacza, który punktuje nowe odpowiedzi, ani pętli <a href="https://paweldubiel.com/glossary/reinforcement-learning">uczenia ze wzmocnieniem</a>, w której generator uczy się z takich ocen. Opis i regułę podają <a href="https://arxiv.org/html/2305.18290v3#S4" rel="noopener noreferrer">Rafailov i współautorzy, <em>Direct Preference Optimization: Your Language Model is Secretly a Reward Model</em>, §4, równanie (7)</a>.</p>
<p><img src="https://paweldubiel.com/assets/dpo-paired-proofs-direct-press-adjustment.webp" alt="Dwie próbne odbitki połączone bezpośrednio z pokrętłem prasy oraz osobna nieruchoma odbitka odniesienia: metafora uczenia z porównań w DPO." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-zmienia-porównanie">Co zmienia porównanie</h2>
<p>Zachowujemy prośbę, oba teksty i wskazanie A. Model przypisuje każdej odpowiedzi prawdopodobieństwo jej wygenerowania. DPO zestawia <strong>wzajemną przewagę A nad B</strong> z przewagą w niezmienianym modelu odniesienia — zwykle kopii modelu z początku tego etapu uczenia. Gdy przewaga A rośnie względem tego punktu startu, błąd tej pary maleje. Trening dostosowuje liczbowe ustawienia modelu, aby zmniejszać takie błędy w zbiorze porównań.</p>
<p>We własnym, celowo małym przykładzie dopuszczamy tylko dwie całe odpowiedzi. Model odniesienia daje A 40%, a B 60%. Po zmianie ustawień model daje A 60%, a B 40%. Stosunek A do B wzrósł z 2/3 do 3/2, czyli 2,25 raza. β jest dodatnim współczynnikiem związanym z kontrolą odejścia od modelu odniesienia; tutaj ustawiamy go na 1. Wtedy błąd DPO tej pary spada z około 0,693 do 0,368. <strong>To ocena zgodności z zapisanym porównaniem, nie pomiar prawdy.</strong> Liczby pokazują możliwą zmianę, a nie gwarantowany wynik jednego kroku treningu.</p>
<p>W rzeczywistym modelu możliwych odpowiedzi jest znacznie więcej. Prawdopodobieństwa A i B nie muszą sumować się do 100%; prawdopodobieństwo całego tekstu powstaje z prawdopodobieństw kolejnych jego kawałków. Uprościliśmy przestrzeń odpowiedzi, zachowując regułę porównania.</p>
<h2 id="punkt-startu-ma-znaczenie">Punkt startu ma znaczenie</h2>
<p>Jeśli kopia odniesienia dawała A 80%, przejście do 60% <strong>zmniejsza</strong> jej przewagę nad B, choć A nadal jest częstsza. Dlatego DPO nie sprowadza się do sprawdzenia „czy A ma ponad połowę?”. Poniżej możesz porównać oba punkty startu.</p>
<div id="dpo-reference-lab"></div>
<h2 id="granica-obietnicy">Granica obietnicy</h2>
<p>DPO może nauczyć się również złej preferencji. Gdy ktoś stale wybiera B za uprzejme brzmienie, etykieta nagradza dopisywanie wyjazdu. Samo zmniejszanie błędu nie odkryje, że powód jest niepodany. To ograniczenie naszego przykładu; <a href="https://arxiv.org/html/2305.18290v3#S7" rel="noopener noreferrer">§7 pracy omawia otwarte pytania o nadmierną optymalizację i przenoszenie zachowania na nowe zadania</a>.</p>
<h2 id="dla-chętnych-skąd-liczba-błędu">Dla chętnych: skąd liczba błędu</h2>
<p>Niech <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>A</mi></msub><mo separator="true">,</mo><msub><mi>p</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">p_A,p_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> oznaczają bieżące prawdopodobieństwa całych odpowiedzi, a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mi>A</mi></msub><mo separator="true">,</mo><msub><mi>r</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">r_A,r_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> — te same wartości w modelu odniesienia. Najpierw liczymy zmianę stosunku:</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>R</mi><mo>=</mo><mfrac><mrow><msub><mi>p</mi><mi>A</mi></msub><mi mathvariant="normal">/</mi><msub><mi>p</mi><mi>B</mi></msub></mrow><mrow><msub><mi>r</mi><mi>A</mi></msub><mi mathvariant="normal">/</mi><msub><mi>r</mi><mi>B</mi></msub></mrow></mfrac></mrow><annotation encoding="application/x-tex">R=\frac{p_A/p_B}{r_A/r_B}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.53em;vertical-align:-0.52em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.01em;"><span style="top:-2.655em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:-0.0278em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span><span class="mord mtight">/</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:-0.0278em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.485em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span><span class="mord mtight">/</span><span class="mord mtight"><span class="mord mathnormal mtight">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.52em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></p>
<p>Symbol ln oznacza logarytm naturalny. Po zmianie znaku ta funkcja zamienia wartość bliską 1 w błąd bliski 0, a małą wartość w duży błąd. Reguła oryginalnego DPO daje przewidywaną preferencję <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><msup><mi>R</mi><mi>β</mi></msup><mi mathvariant="normal">/</mi><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><msup><mi>R</mi><mi>β</mi></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q=R^\beta/(1+R^\beta)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.0991em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0528em;">β</span></span></span></span></span></span></span></span><span class="mord">/</span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.0991em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0528em;">β</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> i błąd <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>L</mi><mo>=</mo><mo>−</mo><mi>ln</mi><mo>⁡</mo><mi>q</mi></mrow><annotation encoding="application/x-tex">L=-\ln q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">L</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord">−</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span>; dodatni współczynnik β ustawiliśmy na 1. Dla R = 2,25 otrzymujemy q ≈ 0,692 i L ≈ 0,368. To przepisanie <a href="https://arxiv.org/html/2305.18290v3#S4" rel="noopener noreferrer">równania (7) z §4</a> i <a href="https://arxiv.org/html/2305.18290v3#A2" rel="noopener noreferrer">kodu z dodatku B</a>, nie osobny algorytm. Im bliżej q do 1, tym mniejszy błąd przypisania etykiety „A lepsza”.</p>
<p>Powiązania:</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback">Reinforcement Learning from Human Feedback</a> w klasycznym wariancie używa osobnego modelu nagrody i późniejszego uczenia ze wzmocnieniem; DPO upraszcza etap uczenia z porównań.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a> jest dalszym uczeniem już istniejącego modelu; DPO określa cel takiego uczenia z par preferencji.</li>
<li><a href="https://paweldubiel.com/glossary/kl-divergence">KL Divergence</a> mierzy różnicę między rozkładami prawdopodobieństw. Ograniczenie tej różnicy występuje w celu, z którego wyprowadzono DPO.</li>
<li><a href="https://paweldubiel.com/glossary/cross-entropy">Cross-entropy</a> wyjaśnia logarytmiczny błąd przypisania etykiety; tutaj etykieta dotyczy porównania dwóch odpowiedzi.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Reinforcement Learning</title>
  <link>https://paweldubiel.com/glossary/reinforcement-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/reinforcement-learning</guid>
  <pubDate>Mon, 05 Oct 2026 08:44:03 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz nauczyć program wygrywać w małej grze. Na rozwidleniu może wybrać drogę A, zebrać dwie monety od razu i zakończyć drugą turę bez nowych monet.</description>
  <content:encoded><![CDATA[<p>Chcesz nauczyć program wygrywać w małej grze. Na rozwidleniu może wybrać drogę A, zebrać dwie monety od razu i zakończyć drugą turę bez nowych monet. Droga B w pierwszej turze nie daje nic, ale w drugiej prowadzi do pięciu monet. Reguła „wybieraj to, co daje najwięcej teraz” wskazuje A, choć po dwóch turach lepszy wynik daje B. Nie masz też zbioru gotowych odpowiedzi wskazujących właściwy ruch w każdej sytuacji. Program może natomiast rozgrywać partie i sprawdzać ich wyniki.</p>
<p><strong>Reinforcement Learning (RL)</strong> to uczenie strategii działania na podstawie doświadczeń i liczbowych ocen skutków działań. Celem jest zwiększanie oczekiwanej łącznej nagrody: wyniku, jaki strategia przynosi przeciętnie w wielu próbach. Nagroda nie musi pojawić się natychmiast po decyzji. Tak opisuje problem oficjalny <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html" rel="noopener noreferrer">Spinning Up, część 1, „Key Concepts and Terminology”, „Reward and Return” oraz „The RL Problem”</a>.</p>
<p><img src="https://paweldubiel.com/assets/reinforcement-learning-two-routes-delayed-reward.webp" alt="Rozwidlona droga na drewnianej planszy: bliższa odnoga prowadzi do małej nagrody, dłuższa do większej." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-program-wyciąga-z-rozegranej-partii">Co program wyciąga z rozegranej partii</h2>
<p>W naszej grze <strong>agent</strong> to program wybierający drogę, a <strong>środowisko</strong> to gra, która wykonuje ruch i przyznaje monety. Program dostaje obserwację, czyli dostępne informacje o sytuacji, na przykład położenie na planszy. <strong>Policy</strong> jest jego regułą wyboru działań; może także określać szanse wyboru różnych ruchów.</p>
<p>Po próbie A program zapisuje wynik „2, potem 0”. Próba B daje „0, potem 5”. Algorytm uczenia wykorzystuje takie doświadczenia, aby poprawić policy, na przykład częściej wybierać B na tym rozwidleniu. To opis celu, nie jedna uniwersalna recepta aktualizacji. Wynik 5 trzeba powiązać z wcześniejszym wyborem B. Jeśli program zawsze wybiera A, nie zbierze informacji o B; dlatego uczenie często wymaga próbowania także mniej znanych działań.</p>
<p>Wymyślona gra ma stałe wyniki i dwie tury. W trudniejszym środowisku ten sam ruch może przynosić różne skutki, dlatego liczy się oczekiwany wynik, a pojedynczy sukces nie dowodzi znalezienia dobrej strategii. Samo porównanie dwóch znanych sum również nie jest jeszcze uczeniem.</p>
<p>W <a href="https://paweldubiel.com/glossary/behavioral-cloning">Behavioral cloning</a> program uczy się naśladować działania z przykładów. W RL informacją kierującą uczeniem jest ocena skutków. W modelach językowych działaniem może być wygenerowanie odpowiedzi, a nagrodą ocena jej poprawności lub przydatności. <a href="https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback">RLHF</a> wykorzystuje do tego informacje pochodzące od ludzi.</p>
<p>Ważna granica: RL poprawia wynik według przyjętej nagrody. Jeśli punkty premiują obchodzenie zasad zamiast zadania, agent może wyuczyć się <a href="https://paweldubiel.com/glossary/reward-hacking-wykorzystywanie-luk-w-systemie-nagrod">Reward hacking</a>. Więcej punktów nie musi oznaczać zachowania, na którym naprawdę nam zależało.</p>
<h2 id="obstaw-drogę-potem-sprawdź-drugą-turę">Obstaw drogę, potem sprawdź drugą turę</h2>
<p>W tym eksperymencie porównujesz cel dwóch strategii, <strong>nie trenujesz agenta</strong>. Wybierz drogę i odsłoń późniejszy wynik. Suwak zmienia znaczenie przyszłej nagrody, nie liczbę zebranych monet.</p>
<p>Liczymy <strong>return</strong>, czyli wynik całej próby: <code>pierwsza nagroda + γ × druga nagroda</code>. Symbol γ (gamma) jest wagą przyszłej nagrody. Przy γ = 1 liczymy obie tury w pełni: A daje 2, B daje 5. Przy γ = 0,2 otrzymujemy A = 2, B = 1. To inny cel oceny tej samej gry. Graniczne γ = 0 i 1 są tutaj dozwolone, bo próba kończy się po dwóch turach; nie jest to nieskończony ciąg nagród. Źródło formalizmu: <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#reward-and-return" rel="noopener noreferrer">Spinning Up, „Reward and Return”</a>.</p>
<div id="rl-delayed-reward-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Reinforcement Learning from Human Feedback</title>
  <link>https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback</guid>
  <pubDate>Mon, 05 Oct 2026 08:44:03 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Prosisz model: „Napisz krótką odmowę zaproszenia, bez podawania powodu”. Dostajesz dwie propozycje. A: „Dziękuję za zaproszenie. Tym razem nie przyjdę”. B: „Dziękuję za zaproszenie.</description>
  <content:encoded><![CDATA[<p>Prosisz model: „Napisz krótką odmowę zaproszenia, bez podawania powodu”. Dostajesz dwie propozycje. A: „Dziękuję za zaproszenie. Tym razem nie przyjdę”. B: „Dziękuję za zaproszenie. Nie przyjdę, bo wyjeżdżam”. Obie brzmią naturalnie, lecz B dopisuje niepodany powód i łamie instrukcję. Samo uczenie przewidywania kolejnych kawałków tekstu nie daje bezpośredniej oceny, która gotowa odpowiedź lepiej służy użytkownikowi. Człowiek może jednak porównać propozycje i wskazać A.</p>
<p><strong>Reinforcement Learning from Human Feedback (RLHF)</strong> wykorzystuje informację zwrotną od ludzi do kierowania uczeniem ze wzmocnieniem. W klasycznym wariancie dla modeli językowych ludzkie porównania uczą osobny model oceniający odpowiedzi; jego wyniki służą następnie jako nagroda w dalszym treningu modelu generującego. Taki przebieg opisują <a href="https://arxiv.org/html/2203.02155v1#S3" rel="noopener noreferrer">Ouyang i współautorzy, <em>Training language models to follow instructions with human feedback</em>, §3.1 i §3.5</a>.</p>
<p><img src="https://paweldubiel.com/assets/rlhf-human-choice-shapes-scoring-template.webp" alt="Dłoń wybierająca jeden z dwóch papierowych kształtów i przenosząca go do formy, jako metafora przekazywania ludzkiej preferencji do oceniacza." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="od-wskazania-a-do-zmiany-sposobu-odpowiadania">Od wskazania A do zmiany sposobu odpowiadania</h2>
<p>W opisanej pracy najpierw doucza się model na przykładach odpowiedzi napisanych przez ludzi. To <strong>Supervised Fine-Tuning (SFT)</strong>: <a href="https://paweldubiel.com/glossary/fine-tuning">Fine-tuning</a>, czyli dalsze uczenie istniejącego modelu, z dostarczonymi odpowiedziami do naśladowania. W naszym przykładzie pokazujemy mu między innymi odmowy bez dopisywania powodów.</p>
<p>Następnie ludzie porównują odpowiedzi na te same prośby. Na wielu takich parach trenuje się <strong>reward model</strong>, osobny model przypisujący odpowiedzi liczbę. Uczy się wystawiać wyższe oceny odpowiedziom preferowanym przez oceniających. Dla naszej pary oznacza to wynik A wyższy od B. Nie potrzeba jednej idealnej wersji odmowy; informacją jest relacja „A jest lepsze od B”.</p>
<p>Potem model generujący tworzy nowe odpowiedzi i dostaje oceny od reward model. Algorytm <a href="https://paweldubiel.com/glossary/reinforcement-learning">Reinforcement Learning</a> zmienia jego parametry, czyli liczby sterujące działaniem, aby zwiększać oczekiwaną nagrodę, czyli średnią ocenę w wielu próbach. W InstructGPT użyto do tego <strong>PPO</strong>, algorytmu stopniowego aktualizowania strategii. Dodano też karę za odchodzenie od wcześniejszego modelu, mierzoną przez <a href="https://paweldubiel.com/glossary/kl-divergence">KL Divergence</a> — miarę różnicy między zestawami szans przypisywanych możliwym odpowiedziom. Ograniczała ona nadmierne dopasowanie do oceniacza (<a href="https://arxiv.org/html/2203.02155v1#A3.SS4" rel="noopener noreferrer">§3.5, dodatek C.4</a>).</p>
<p>Po takim treningu odmowy podobne do A mogą pojawiać się częściej. <strong>Zmienia się model</strong>, nie tylko wybór spośród dwóch gotowych tekstów. Człowiek nie musi oceniać każdej odpowiedzi w każdym kroku; w tym wariancie zastępuje go wyuczony oceniacz. To jeden konkretny przebieg RLHF, nie obowiązkowa recepta każdego współczesnego modelu.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/direct-preference-optimization">Direct Preference Optimization</a> — uczenie z par preferencji bez osobnego modelu nagrody i pętli RL.</p>
<p>Ograniczenie: oceniacz przewiduje preferencje określonej grupy według jej instrukcji, a nie obiektywną prawdę. Gdy ludzie nagradzają wiarygodnie brzmiący, dopisany powód, model może uczyć się go naśladować. RLHF nie gwarantuje rzetelności ani zgodności z intencją każdego użytkownika; autorzy opisują pozostałe błędy i ograniczenia grupy oceniającej w <a href="https://arxiv.org/html/2203.02155v1#S5.SS2" rel="noopener noreferrer">§5.2–5.3</a>.</p>
<h2 id="naucz-mały-oceniacz-jednej-preferencji">Naucz mały oceniacz jednej preferencji</h2>
<p>Wskaż, którą odpowiedź uznała za lepszą przykładowa grupa ludzi, i wykonuj kroki uczenia. Zobaczysz <strong>przewidywanie preferencji</strong>, nie szansę wygenerowania odpowiedzi. Wybierz też B: czy wyższy wynik usuwa dopisany powód?</p>
<p>Eksperyment izoluje etap reward model. Ma tylko dwa swobodnie zmieniane wyniki, A i B; nie czyta języka, nie uogólnia na nowe prośby i nie wykonuje PPO. Po pierwszym kroku dla A wyniki zmienią się z 0/0 na 0,25/−0,25, a przewidywana szansa preferowania A wzrośnie z 50% do około 62,2%. Teksty pozostają identyczne.</p>
<div id="rlhf-preference-lab"></div>
<h3 id="skąd-biorą-się-liczby">Skąd biorą się liczby</h3>
<p>Z różnicy wyników obliczamy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo stretchy="false">(</mo><mi>A</mi><mo stretchy="false">)</mo><mo>=</mo><mn>1</mn><mi mathvariant="normal">/</mi><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><msup><mi>e</mi><mrow><mo>−</mo><mo stretchy="false">(</mo><msub><mi>r</mi><mi>A</mi></msub><mo>−</mo><msub><mi>r</mi><mi>B</mi></msub><mo stretchy="false">)</mo></mrow></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">p(A)=1/(1+e^{-(r_A-r_B)})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">A</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1/</span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.138em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.888em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mopen mtight">(</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:-0.0278em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3448em;"><span style="top:-2.3567em;margin-left:-0.0278em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1433em;"><span></span></span></span></span></span></span><span class="mclose mtight">)</span></span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span>. <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mi>A</mi></msub></mrow><annotation encoding="application/x-tex">r_A</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">r_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> to oceny odpowiedzi, a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>e</mi></mrow><annotation encoding="application/x-tex">e</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">e</span></span></span></span> to stała matematyczna, około 2,718. Ten wzór zamienia różnicę ocen na wartość od 0 do 1. Przy równych ocenach daje 0,5. Strata to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mi>l</mi><mi>n</mi><mi>p</mi><mo stretchy="false">(</mo><mi>e</mi><mi>x</mi><mi>t</mi><mrow><mi>p</mi><mi>r</mi><mi>e</mi><mi>f</mi><mi>e</mi><mi>r</mi><mi>o</mi><mi>w</mi><mi>a</mi><mi>n</mi><mi>a</mi></mrow><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">-ln p(	ext{preferowana})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">−</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mord mathnormal">n</span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">e</span><span class="mord mathnormal">x</span><span class="mord mathnormal">t</span><span class="mord"><span class="mord mathnormal">p</span><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="mord mathnormal">e</span><span class="mord mathnormal" style="margin-right:0.1076em;">f</span><span class="mord mathnormal" style="margin-right:0.0278em;">er</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mord mathnormal">ana</span></span><span class="mclose">)</span></span></span></span>: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ln</mi><mo>⁡</mo></mrow><annotation encoding="application/x-tex">\ln</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mop">ln</span></span></span></span> oznacza logarytm naturalny, funkcję, która wraz z minusem daje większą karę za mniejszą szansę etykiety od ludzi. To postać porównania z <a href="https://arxiv.org/html/2203.02155v1#S3.SS5" rel="noopener noreferrer">§3.5, równanie (1)</a>.</p>
<p>Tutaj aktualizujemy <strong>dwa wyniki bezpośrednio</strong>, zamiast parametrów rzeczywistej sieci. Dla etykiety A zwiększamy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mi>A</mi></msub></mrow><annotation encoding="application/x-tex">r_A</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">A</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> o <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,5</mn><mo stretchy="false">(</mo><mn>1</mn><mo>−</mo><mi>p</mi><mo stretchy="false">(</mo><mi>A</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">0{,}5(1-p(A))</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">A</span><span class="mclose">))</span></span></span></span> i o tyle samo zmniejszamy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>r</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">r_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">r</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span>. Dla B robimy ruch w przeciwną stronę, o <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,5</mn><mi>p</mi><mo stretchy="false">(</mo><mi>A</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">0{,}5p(A)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">A</span><span class="mclose">)</span></span></span></span>. Stała 0,5 jest wybranym krokiem naszego przykładu. Nie jest ustawieniem treningu z papera.</p>]]></content:encoded>
</item>
<item>
  <title>Dense retrieval</title>
  <link>https://paweldubiel.com/glossary/dense-retrieval</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/dense-retrieval</guid>
  <pubDate>Sun, 04 Oct 2026 15:08:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>information-retrieval</category>
  <description>Dense retrieval to wyszukiwanie dokumentów przez podobieństwo wektorów obliczonych przez wyuczony model. Model zamienia zapytanie na listę liczb i robi to samo dla dokumentów.</description>
  <content:encoded><![CDATA[<p>Dense retrieval to wyszukiwanie dokumentów przez podobieństwo wektorów obliczonych przez wyuczony model. Model zamienia zapytanie na listę liczb i robi to samo dla dokumentów. Wyszukiwarka porównuje te reprezentacje, na przykład za pomocą podobieństwa cosinusowego, i zwraca dokumenty o najwyższych wynikach.</p>
<p>Wektory dokumentów można obliczyć wcześniej i zapisać w indeksie. Podczas obsługi pytania trzeba obliczyć reprezentację zapytania oraz wyszukać bliskie wektory. Jest to osobny koszt od późniejszego czytania i oceniania dokumentów przez model językowy.</p>
<p>Przykład przygotowany do wyjaśnienia: pytasz, jak rozpocząć zbieranie danych dla nieskutecznego jeszcze agenta. Praca o ocenie gotowych agentów może uzyskać wysoki wynik podobieństwa, bo opisuje podobne zadanie. Publikacja o uczeniu z demonstracji może zawierać przydatne rozwiązanie, lecz używać innego słownictwa. Trafienie zależy od reprezentacji wyuczonej przez model, nie tylko od wspólnych słów; mimo to podobieństwo wektorów nie gwarantuje przydatności pomysłu.</p>
<p>W <a href="https://paweldubiel.com/articles/scholarcatalyst-agent-nie-poprawil-wyszukiwania-uzytecznych-prac">opisie ScholarCatalyst</a> Gemini Embedding 2 tworzy pierwszą listę prac na podstawie tytułów i abstraktów. Agent może wygenerować kolejne zapytania, lecz nadal korzysta z tego retrievera. Późniejszy reranking ocenia tylko dokumenty, które weszły do puli. Własny test powinien więc sprawdzać także obecność znanych użytecznych prac przed tym etapem.</p>
<p>Źródło zastosowania: <a href="https://arxiv.org/html/2610.02202v1" rel="noopener noreferrer">ScholarCatalyst, dodatek C.1</a>.</p>]]></content:encoded>
</item>
<item>
  <title>Recall@k</title>
  <link>https://paweldubiel.com/glossary/recall-k</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/recall-k</guid>
  <pubDate>Sun, 04 Oct 2026 15:07:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>information-retrieval</category>
  <description>Recall@k mierzy, jaka część znanych trafnych dokumentów znalazła się w pierwszych k wynikach wyszukiwania.</description>
  <content:encoded><![CDATA[<p>Recall@k mierzy, jaka część znanych trafnych dokumentów znalazła się w pierwszych k wynikach wyszukiwania. Liczymy trafne dokumenty na tej krótkiej liście i dzielimy ich liczbę przez liczbę wszystkich dokumentów oznaczonych jako trafne dla danego pytania. Wyższa wartość jest lepsza.</p>
<p>Przykład przygotowany do wyjaśnienia: badacz wskazał trzy publikacje pomocne dla konkretnego problemu. Wyszukiwarka zwróciła pięć wyników, w tym dwie ze wskazanych publikacji. Recall@5 wynosi 2/3, czyli około 0,67. Trzecia użyteczna praca na szóstej pozycji nie zwiększy Recall@5. Dwie użyteczne pozycje na pięć wyników dają zarazem precision@5 = 2/5 = 0,40; to inna metryka, z innym mianownikiem.</p>
<p>W <a href="https://paweldubiel.com/articles/scholarcatalyst-agent-nie-poprawil-wyszukiwania-uzytecznych-prac">opisie ScholarCatalyst</a> trafna praca oznacza publikację, której pomysł autor projektu uznał za pomocny lub potencjalnie pomocny. Oficjalny kod liczy Recall@k osobno dla każdego pytania, a potem uśrednia te wartości. Nie sumuje najpierw wszystkich trafień z całego benchmarku.</p>
<p>Metryka zależy od etykiet. Użyteczna praca nieznana osobom nadającym etykiety nie zostanie zaliczona jako trafienie, a wysokie Recall@k nie dowodzi, że agent potrafi zastosować znaleziony pomysł. Aby oddzielić błędy wyszukiwania od błędów końcowego wyboru, porównaj pozytywne dokumenty widziane przez agenta z tymi, które zwrócił na liście.</p>
<p>Źródła: <a href="https://arxiv.org/html/2610.02202v1" rel="noopener noreferrer">ScholarCatalyst</a> i <a href="https://github.com/stanford-iris-lab/ScholarCatalyst/blob/main/src/evaluation/evaluate.py" rel="noopener noreferrer">oficjalny kod ewaluacji</a>.</p>]]></content:encoded>
</item>
<item>
  <title>Nesterov Momentum</title>
  <link>https://paweldubiel.com/glossary/nesterov-momentum</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/nesterov-momentum</guid>
  <pubDate>Sun, 04 Oct 2026 07:22:27 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Uczysz model przewidywać czas dostawy. W naszym małym przykładzie właściwa odpowiedź to 10 minut, a bieżąca prognoza wynosi 9.</description>
  <content:encoded><![CDATA[<p>Uczysz model przewidywać czas dostawy. W naszym małym przykładzie właściwa odpowiedź to 10 minut, a bieżąca prognoza wynosi 9. Wcześniejsze poprawki zwiększały prognozę; zachowana część ich ruchu chce dodać jeszcze 2 minuty. Sama bieżąca wskazówka też mówi „zwiększ”. Połączenie obu może jednak przenieść prognozę za daleko. Przydałoby się sprawdzić, jak wygląda błąd tam, dokąd niesie model jego pamięć.</p>
<p><strong>Nesterov Momentum</strong>, nazywane też <em>Nesterov Accelerated Gradient</em> (NAG), to wariant aktualizacji modelu z pamięcią wcześniejszych ruchów: nową wskazówkę oblicza w przewidywanym położeniu po zachowanej części poprzedniego ruchu. Następnie koryguje ten ruch. Nie przewiduje przyszłych danych — ocenia ten sam przykład przy innym ustawieniu modelu. Taką postać opisują <a href="https://proceedings.mlr.press/v28/sutskever13.pdf#page=3" rel="noopener noreferrer">Sutskever i współautorzy, §2, równania 3–4 oraz §2.1</a>.</p>
<p><img src="https://paweldubiel.com/assets/nesterov-momentum-cart-lookahead-probe.webp" alt="Wózek z długim ramieniem i sondą dotykającą wznoszącego się toru przed jego kołami, jako metafora sprawdzania miejsca przewidywanego ruchu." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="ta-sama-prognoza-dwa-miejsca-sprawdzenia">Ta sama prognoza, dwa miejsca sprawdzenia</h2>
<p>Oceniamy błąd jako połowę kwadratu różnicy między prognozą a 10. To <strong>funkcja straty</strong>: liczba, którą chcemy zmniejszać. Jej <strong>gradient</strong>, czyli wskazówka, jak mała zmiana prognozy wpływa na stratę, wynosi <code>prognoza − 10</code>. Ujemny podpowiada zwiększenie, dodatni — zmniejszenie. Współczynnik uczenia (<em>learning rate</em>) <code>0,2</code> ustala wielkość reakcji.</p>
<p>Zwykłe <a href="https://paweldubiel.com/glossary/momentum">Momentum</a> sprawdza gradient przy 9: otrzymuje <code>−1</code>. Nowa poprawka dodaje <code>0,2</code>, obok zachowanego ruchu <code>+2</code>. Prognoza wynosi <strong>11,2</strong>.</p>
<p>Nesterov najpierw wyznacza punkt sprawdzenia: <code>9 + 2 = 11</code>. Gradient wynosi tam <code>+1</code>, więc nowa poprawka odejmuje <code>0,2</code>. Wynik to <strong>10,8</strong>. Zachowany ruch nadal zwiększa prognozę, ale wskazówka już go hamuje. Strata spada z <code>0,5</code> do <code>0,32</code>; zwykłe Momentum podnosi ją do <code>0,72</code>. To własny przykład jednej aktualizacji z identycznego stanu, nie porównanie całych treningów.</p>
<h2 id="sprawdzenie-z-wyprzedzeniem-nie-gwarantuje-sukcesu">Sprawdzenie z wyprzedzeniem nie gwarantuje sukcesu</h2>
<p>Zwiększ zachowany ruch do <code>+3</code>. Nesterov sprawdzi punkt 12 i odejmie <code>0,4</code>, lecz skończy na <strong>11,6</strong>. Strata <code>1,28</code> jest większa niż początkowe <code>0,5</code>. Wcześniejsza korekta nie usuwa potrzeby dobierania wielkości kroków i pamięci. Także teoretyczne przewagi metody wymagają określonych warunków; nie są obietnicą szybszego treningu każdego LLM.</p>
<p>Poniżej zmieniasz zachowaną część ruchu, pozostawiając prognozę 9 i współczynnik 0,2. Najpierw przewidź wynik przy <code>+2</code>, potem odsłoń oba warianty. Przy zerowym zachowanym ruchu obie wskazówki i wyniki się pokryją. Każde ustawienie opisuje osobny, hipotetyczny stan — suwak nie odtwarza wcześniejszych kroków treningu.</p>
<div id="nesterov-lookahead-lab"></div>
<h2 id="zapis-dla-jednego-ustawienia">Zapis dla jednego ustawienia</h2>
<p>Po intuicji można zapisać regułę z pracy:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>y</mi><mi>t</mi></msub><mo>=</mo><msub><mi>w</mi><mi>t</mi></msub><mo>+</mo><mi>μ</mi><msub><mi>v</mi><mi>t</mi></msub></mrow><annotation encoding="application/x-tex">y_t=w_t+\mu v_t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">μ</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>v</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><mi>μ</mi><msub><mi>v</mi><mi>t</mi></msub><mo>−</mo><mi>η</mi><mi>g</mi><mo stretchy="false">(</mo><msub><mi>y</mi><mi>t</mi></msub><mo stretchy="false">)</mo><mo separator="true">,</mo><mspace width="2em"></mspace><msub><mi>w</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><msub><mi>w</mi><mi>t</mi></msub><mo>+</mo><msub><mi>v</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">v_{t+1}=\mu v_t-\eta g(y_t),\qquad w_{t+1}=w_t+v_{t+1}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6389em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7778em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">μ</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">η</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">y</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:2em;"></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6389em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mord">.</span></span></span></span></span>
<p><code>w</code> to bieżące ustawienie (tutaj prognoza), <code>v</code> — poprzedni ruch, <code>μ</code> — zachowana jego część, <code>y</code> — punkt sprawdzenia, <code>g(y)</code> — gradient obliczony w tym punkcie, <code>η</code> — współczynnik uczenia, a <code>t</code> — numer kroku. Nasze <code>+2</code> oznacza już <code>μv</code>, np. <code>0,8 × 2,5</code>. W rzeczywistym modelu ustawień jest wiele; reguła działa na listach liczb.</p>
<p>To konwencja z równań 3–4 paperu. <a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.SGD.html#sgd" rel="noopener noreferrer">PyTorch 2.11 SGD, reguła i uwaga o Momentum/Nesterov</a> zapisuje wariant przez bufor gradientów i zmienną opisującą inne położenie; nie należy podstawiać naszego <code>w</code> i <code>v</code> bezpośrednio jako jego parametrów i bufora. Demonstracja liczy wskazaną wyżej regułę z pracy.</p>
<h2 id="powiązania">Powiązania</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/momentum">Momentum</a> zachowuje ruch, ale w podstawowej postaci sprawdza gradient przy bieżącym ustawieniu.</li>
<li><a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">Stochastic Gradient Descent</a> wyznacza wskazówki z losowo wybranych danych; można połączyć je z Nesterov Momentum. Nasz przykład ma stały cel i nie pokazuje losowości próbkowania.</li>
<li><a href="https://paweldubiel.com/glossary/optimizer-state">Optimizer State</a> obejmuje pamięć potrzebną do kontynuacji aktualizacji, tutaj wcześniejszy ruch, a nie samą prognozę.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Sharpening Tax</title>
  <link>https://paweldubiel.com/glossary/sharpening-tax</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/sharpening-tax</guid>
  <pubDate>Sat, 03 Oct 2026 20:28:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>training</category>
  <description>Model może lepiej wykonywać pojedynczą próbę, a jednocześnie mniej zyskiwać z ponawiania zadania. Sharpening Tax to zaproponowana w Sharpening Tax in Post-Training miara zmiany korzyści z powtórek…</description>
  <content:encoded><![CDATA[<p>Model może lepiej wykonywać pojedynczą próbę, a jednocześnie mniej zyskiwać z ponawiania zadania. <strong>Sharpening Tax</strong> to zaproponowana w <em>Sharpening Tax in Post-Training</em> miara zmiany korzyści z powtórek po dalszym treningu modelu. Jej mechanizm i ograniczenia opisuje <a href="https://paweldubiel.com/articles/lepsza-pierwsza-proba-nie-gwarantuje-skuteczniejszych-powtorek-agenta">notatka o skuteczności powtórek agenta</a>.</p>
<p>Punktem wyjścia jest <a href="https://paweldubiel.com/glossary/pass-k">pass@k</a>: prawdopodobieństwo uzyskania przynajmniej jednego poprawnego wykonania wśród k prób. Dla kolejnych budżetów powstaje krzywa. Nie wskazuje ona, którą odpowiedź należy wybrać; do praktycznego wykorzystania udanej próby potrzebny jest weryfikator.</p>
<h2 id="pole-pod-różnicą-względem-końcowego-wyniku">Pole pod różnicą względem końcowego wyniku</h2>
<p>Oznaczmy skuteczność przy budżecie k przez C(k), a maksymalny rozpatrywany budżet przez K. Autorzy definiują:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>A</mi><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mo>=</mo><munderover><mo>∑</mo><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><mrow><mi>K</mi><mo>−</mo><mn>1</mn></mrow></munderover><mrow><mo fence="true">[</mo><mi>C</mi><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mo>−</mo><mi>C</mi><mo stretchy="false">(</mo><mi>k</mi><mo stretchy="false">)</mo><mo fence="true">]</mo></mrow><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">A(K)=\sum_{k=1}^{K-1}\left[C(K)-C(k)\right].</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">A</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:3.1304em;vertical-align:-1.3021em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.8283em;"><span style="top:-1.8479em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0315em;">k</span><span class="mrel mtight">=</span><span class="mord mtight">1</span></span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span><span style="top:-4.3em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0715em;">K</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.3021em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;">[</span><span class="mord mathnormal" style="margin-right:0.0715em;">C</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mord mathnormal" style="margin-right:0.0715em;">C</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mclose">)</span><span class="mclose delimcenter" style="top:0em;">]</span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">.</span></span></span></span></span>
<p>Dla każdego mniejszego budżetu odejmujemy aktualną skuteczność od wyniku przy pełnym budżecie. Dodajemy te różnice. Duża wartość oznacza, że sukcesy pojawiają się dopiero po dołożeniu prób. W rachunku skuteczność zapisujemy jako prawdopodobieństwo od zera do jednego.</p>
<p>Poniższy rachunek jest przykładem dydaktycznym, nie wynikiem papera. Przy budżetach jednej, dwóch i trzech prób skuteczność wynosi odpowiednio 0,2, 0,4 i 0,6. Dla K = 3 suma wynosi (0,6 − 0,2) + (0,6 − 0,4), czyli 0,6. Jeżeli inny model osiąga 0,6 już w jednej próbie i zachowuje ten wynik, suma wynosi zero. Brak dalszego przyrostu może więc wynikać z szybszego osiągnięcia tego samego wyniku, nie z jego pogorszenia.</p>
<h2 id="normalizacja-i-porównanie-modeli">Normalizacja i porównanie modeli</h2>
<p>Wersja znormalizowana uwzględnia odsetek zadań nieudanych w pojedynczej próbie:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>S</mi><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mrow><mi>A</mi><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo></mrow><mrow><mo stretchy="false">(</mo><mi>K</mi><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo><mrow><mo fence="true">[</mo><mn>1</mn><mo>−</mo><mi>C</mi><mo stretchy="false">(</mo><mn>1</mn><mo stretchy="false">)</mo><mo fence="true">]</mo></mrow></mrow></mfrac><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">S(K)=\frac{A(K)}{(K-1)\left[1-C(1)\right]}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0576em;">S</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.363em;vertical-align:-0.936em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.427em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mord">1</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;">[</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mord mathnormal" style="margin-right:0.0715em;">C</span><span class="mopen">(</span><span class="mord">1</span><span class="mclose">)</span><span class="mclose delimcenter" style="top:0em;">]</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">A</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.936em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord">.</span></span></span></span></span>
<p>W podanym przykładzie mianownik wynosi 2 razy 0,8, czyli 1,6; S(3) wynosi 0,375. K musi być liczbą całkowitą nie mniejszą niż dwa. Gdy C(1) wynosi jeden, mianownik jest zerowy i ten wariant miary nie jest określony.</p>
<p>Znormalizowany Sharpening Tax jest różnicą między skalowalnością wersji bazowej a skalowalnością po dalszym treningu:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mrow><mi mathvariant="normal">T</mi><mi mathvariant="normal">a</mi><mi mathvariant="normal">x</mi></mrow><mi>S</mi></msub><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>S</mi><mrow><mi mathvariant="normal">b</mi><mi mathvariant="normal">a</mi><mi mathvariant="normal">s</mi><mi mathvariant="normal">e</mi></mrow></msub><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mo>−</mo><msub><mi>S</mi><mrow><mi mathvariant="normal">p</mi><mi mathvariant="normal">o</mi><mi mathvariant="normal">s</mi><mi mathvariant="normal">t</mi></mrow></msub><mo stretchy="false">(</mo><mi>K</mi><mo stretchy="false">)</mo><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">\mathrm{Tax}_{S}(K)=S_{\mathrm{base}}(K)-S_{\mathrm{post}}(K).</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord"><span class="mord mathrm">Tax</span></span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0576em;">S</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0576em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3361em;"><span style="top:-2.55em;margin-left:-0.0576em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">base</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.0361em;vertical-align:-0.2861em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0576em;">S</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0576em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">post</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mclose">)</span><span class="mord">.</span></span></span></span></span>
<p>Porównanie wymaga tych samych zadań, budżetu i reguł wyznaczania skuteczności. Dodatnia wartość oznacza mniejsze korzyści z dokładania prób po treningu według tej miary. Nie dowodzi sama w sobie, że końcowy pass@K jest niższy.</p>
<h2 id="zerowy-wynik-może-opisywać-sukces-albo-całkowitą-porażkę">Zerowy wynik może opisywać sukces albo całkowitą porażkę</h2>
<p>Jeśli model zawsze odnosi sukces, wszystkie różnice w A(K) są zerowe. Tak samo jest, jeśli nie odnosi sukcesu przy żadnym budżecie. Dlatego A(K), S(K) i ich różnice trzeba odczytywać razem z krzywą pass@k i jej końcowym punktem.</p>
<p>W pracy autorzy szacują krzywe z liczby sukcesów osobno dla każdego zadania, a następnie uśredniają zadania z równymi wagami. Skończona liczba prób nie pozwala utożsamić braku zaobserwowanego sukcesu z zerowym prawdopodobieństwem sukcesu. W zastosowaniu porównuj zmianę korzyści z powtórek z końcową skutecznością oraz kosztem uzyskania sprawdzonego rezultatu.</p>
<p>Źródło: Changdae Oh i współautorzy, <a href="https://arxiv.org/html/2610.01509v1" rel="noopener noreferrer"><em>Sharpening Tax in Post-Training</em>, §4 i dodatki B.1–B.2</a>, preprint arXiv:2610.01509v1 z 1 października 2026, na licencji <a href="https://creativecommons.org/licenses/by/4.0/" rel="noopener noreferrer">CC BY 4.0</a>.</p>]]></content:encoded>
</item>
<item>
  <title>AdamW</title>
  <link>https://paweldubiel.com/glossary/adamw</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/adamw</guid>
  <pubDate>Sat, 03 Oct 2026 08:29:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Przewidujesz liczbę zgłoszeń do działu wsparcia. Prosty model liczy „liczba zespołów × a + b”: a określa wkład jednego zespołu, a b stałą część prognozy. Te uczone liczby to wagi.</description>
  <content:encoded><![CDATA[<p>Przewidujesz liczbę zgłoszeń do działu wsparcia. Prosty model liczy „liczba zespołów × a + b”: a określa wkład jednego zespołu, a b stałą część prognozy. Te uczone liczby to <strong>wagi</strong>. Przy dwóch zespołach, a = 2 i b = 10 model przewiduje 14 zgłoszeń — dokładnie tyle, ile było w przykładzie.</p>
<p>Masz jednak mało danych. Chcesz ograniczać wielkość wag, żeby model nie opierał się bez potrzeby na dużych liczbach. Jedna metoda dodaje do oceny błędu karę za duże wagi. Przy algorytmie Adam taka kara przechodzi przez mechanizm dobierania kroku i nie daje tego samego efektu co bezpośrednie pomniejszenie każdej wagi o ten sam procent.</p>
<p><strong>AdamW</strong> to wariant <a href="https://paweldubiel.com/glossary/adam">Adam</a>, który oddziela aktualizację wynikającą z błędu na danych od <a href="https://paweldubiel.com/glossary/weight-decay">weight decay</a> — proporcjonalnego przyciągania wag do zera. Adam nadal dobiera poprawkę dla każdej wagi na podstawie historii wskazówek z uczenia. Dodatkowe kurczenie omija ten mechanizm i nie trafia do jego zapamiętywanych statystyk. <a href="https://arxiv.org/html/1711.05101v3#S2" rel="noopener noreferrer">Loshchilov i Hutter, §2 i algorytm 2</a>, opisują właśnie takie rozdzielenie.</p>
<p><img src="https://paweldubiel.com/assets/adamw-gears-independent-bypass-band.webp" alt="Mechanizm z zębatkami i osobny turkusowy pas prowadzony wokół nich do obejmy, jako metafora kurczenia wag poza mechanizmem dobierania kroku Adam." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-zmienia-się-w-naszym-przykładzie">Co zmienia się w naszym przykładzie?</h2>
<p><strong>Strata</strong> to liczba oceniająca niedopasowanie prognozy. Tu przyjmujemy połowę kwadratu błędu. <strong>Gradient</strong> wskazuje, jak mała zmiana wag wpływa na tę stratę. Ponieważ prognoza 14 trafia w cel 14, gradient błędu wynosi zero.</p>
<p>Dla czytelnego porównania wykonajmy pierwszy krok ze świeżą pamięcią optymalizatora — algorytmu zmieniającego wagi. Ustawiamy learning rate, czyli współczynnik wielkości kroku, na 0,1, a siłę regulacji na 0,1:</p>




















<table><thead><tr><th>Metoda</th><th>Waga a: start 2</th><th>Waga b: start 10</th></tr></thead><tbody><tr><td>Adam z karą L2</td><td>około 1,9, spadek o 5%</td><td>około 9,9, spadek o 1%</td></tr><tr><td>AdamW</td><td>1,98, spadek o 1%</td><td>9,9, spadek o 1%</td></tr></tbody></table>
<p>Kara <strong>L2</strong> rośnie z sumą kwadratów wag. Dopisuje do gradientu wskazówki 0,2 i 1. W tym pierwszym kroku Adam dzieli każdą z nich przez niemal jej własną wielkość: obie poprawki stają się bliskie 0,1. Znika proporcja, której mogliśmy oczekiwać.</p>
<p>W AdamW gradient z danych pozostaje zerowy, a osobne kurczenie odejmuje 0,1 × 0,1 × wagę: odpowiednio 0,02 i 0,1. Stosujemy tu konwencję <a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.AdamW.html" rel="noopener noreferrer">PyTorch 2.11, reguła AdamW</a>, w której decay jest mnożony przez learning rate. Oddzielenie dotyczy mechanizmu adaptacji, nie pełnej niezależności od wszystkich ustawień.</p>
<p><strong>Ograniczenie:</strong> prognoza AdamW spada do 13,86, więc dopasowanie tego przykładu się pogarsza. Regulacja może pomóc na nowych danych, ale nie gwarantuje tego; zbyt silne kurczenie przeszkadza w uczeniu. To własny przykład dwóch wag, nie wynik treningu LLM. Równe poprawki Adam dotyczą tego pierwszego kroku i jego założeń, nie całego treningu.</p>
<h2 id="sprawdź-czy-oba-pokrętła-robią-to-samo">Sprawdź, czy oba pokrętła robią to samo</h2>
<p>Zanim odsłonisz wynik, przewidź: czy dwukrotnie większa siła regulacji podwoi obie poprawki? Każde ustawienie liczy pierwszy krok od nowa.</p>
<div id="adamw-decay-lab"></div>
<p>Dwukrotnie większy współczynnik podwaja osobny decay AdamW przy stałym learning rate. W pokazanym pierwszym kroku Adam z dodatnią karą L2 nadal odejmuje około 0,1 od każdej wagi. Późniejsze kroki uwzględniają historię i zmieniające się błędy, więc nie powtarzają automatycznie tej sytuacji.</p>
<details>
<summary>Dokładne założenia rachunku</summary>
<p>Dane są wymyślone. Strata z danych wynosi <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>L</mi><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo stretchy="false">(</mo><mn>2</mn><mi>a</mi><mo>+</mo><mi>b</mi><mo>−</mo><mn>14</mn><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L = \frac12(2a+b-14)^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">L</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1901em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em;"><span style="top:-2.655em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mopen">(</span><span class="mord">2</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7778em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.0641em;vertical-align:-0.25em;"></span><span class="mord">14</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span>. Kara L2 ma postać <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi>λ</mi><mn>2</mn></mfrac><mo stretchy="false">(</mo><msup><mi>a</mi><mn>2</mn></msup><mo>+</mo><msup><mi>b</mi><mn>2</mn></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\frac{\lambda}{2}(a^2+b^2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.2251em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em;"><span style="top:-2.655em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">λ</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">a</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.0641em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span>, dlatego dopisuje do gradientów <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mi>a</mi></mrow><annotation encoding="application/x-tex">\lambda a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λa</span></span></span></span> i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mi>b</mi></mrow><annotation encoding="application/x-tex">\lambda b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λb</span></span></span></span>. Symbole <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mo separator="true">,</mo><mi>b</mi></mrow><annotation encoding="application/x-tex">a,b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">b</span></span></span></span> oznaczają wagi, a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> siłę regulacji.</p>
<p>Adam pamięta średnią gradientów oraz średnią ich kwadratów. Współczynniki <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>β</mi><mn>1</mn></msub></mrow><annotation encoding="application/x-tex">\beta_1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0528em;">β</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0528em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>β</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">\beta_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0528em;">β</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0528em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> określają, jak mocno zachowuje poprzednie wartości tych średnich. Małe <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ϵ</mi></mrow><annotation encoding="application/x-tex">\epsilon</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">ϵ</span></span></span></span> w mianowniku zapobiega dzieleniu przez zero. Ustawiamy obie początkowe średnie na zero, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>β</mi><mn>1</mn></msub><mo>=</mo><mn>0,9</mn></mrow><annotation encoding="application/x-tex">\beta_1=0{,}9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0528em;">β</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0528em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">9</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>β</mi><mn>2</mn></msub><mo>=</mo><mn>0,999</mn></mrow><annotation encoding="application/x-tex">\beta_2=0{,}999</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0528em;">β</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0528em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">999</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ϵ</mi><mo>=</mo><msup><mn>10</mn><mrow><mo>−</mo><mn>8</mn></mrow></msup></mrow><annotation encoding="application/x-tex">\epsilon=10^{-8}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">ϵ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord">1</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">8</span></span></span></span></span></span></span></span></span></span></span></span> i wykonujemy korektę ich początkowego zaniżenia. W pierwszym kroku poprawka każdej dodatniej wagi wynosi <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>η</mi><mtext> </mtext><mi>λ</mi><mi>w</mi><mi mathvariant="normal">/</mi><mo stretchy="false">(</mo><mi mathvariant="normal">∣</mi><mi>λ</mi><mi>w</mi><mi mathvariant="normal">∣</mi><mo>+</mo><mi>ϵ</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\eta\,\lambda w/(|\lambda w|+\epsilon)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">η</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">λ</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mord">/</span><span class="mopen">(</span><span class="mord">∣</span><span class="mord mathnormal">λ</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mord">∣</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">ϵ</span><span class="mclose">)</span></span></span></span>, gdzie <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>η</mi><mo>=</mo><mn>0,1</mn></mrow><annotation encoding="application/x-tex">\eta=0{,}1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">η</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span></span></span></span> to learning rate, a <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>w</mi></mrow><annotation encoding="application/x-tex">w</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span></span></span></span> dana waga. Przy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">\lambda=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span> poprawka wynosi dokładnie zero. Widget zachowuje <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ϵ</mi></mrow><annotation encoding="application/x-tex">\epsilon</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">ϵ</span></span></span></span> w obliczeniach; tabela zaokrągla wynik.</p>
<p>W AdamW poprawka Adam z danych wynosi zero, a nowa waga to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo>−</mo><mi>η</mi><mi>λ</mi><mo stretchy="false">)</mo><mi>w</mi></mrow><annotation encoding="application/x-tex">(1-\eta\lambda)w</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">η</span><span class="mord mathnormal">λ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span></span></span></span>. Pamięć początkowa jest zerowa: przy niezerowej historii Adam mógłby wykonać ruch mimo zerowego bieżącego gradientu. Zmiana suwaka nie jest kolejnym krokiem treningu.</p>
</details>
<h2 id="powiązania">Powiązania</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/adam">Adam</a> wyznacza część kroku opartą na danych; AdamW zmienia sposób dołączania kurczenia.</li>
<li><a href="https://paweldubiel.com/glossary/weight-decay">Weight decay</a> opisuje samo przyciąganie do zera.</li>
<li><a href="https://paweldubiel.com/glossary/optimizer-state">Optimizer State</a> wyjaśnia, dlaczego historia wcześniejszych gradientów zmienia późniejsze kroki.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Momentum</title>
  <link>https://paweldubiel.com/glossary/momentum</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/momentum</guid>
  <pubDate>Fri, 02 Oct 2026 09:32:34 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz nauczyć prosty model przewidywać czas dostawy. W naszym małym przykładzie właściwy wynik to 10 minut, a model zaczyna od 6.</description>
  <content:encoded><![CDATA[<p>Chcesz nauczyć prosty model przewidywać czas dostawy. W naszym małym przykładzie właściwy wynik to 10 minut, a model zaczyna od 6. Po każdej poprawce sprawdza, w którą stronę dalej zmienić przewidywanie. Jeśli pamięta tylko ostatnią wskazówkę, nie wykorzystuje tego, że kilka wcześniejszych prowadziło w tę samą stronę.</p>
<p><strong>Momentum</strong> dodaje do kolejnych poprawek modelu pamięć wcześniejszych wskazówek. Zachowuje część poprzedniego śladu i łączy ją z nowym gradientem — informacją, jak mała zmiana ustawienia wpływa na błąd. Zgodne wskazówki mogą się wzmacniać; wpływ dawnych stopniowo słabnie. Podstawowy wariant, <em>classical momentum</em>, opisują <a href="https://proceedings.mlr.press/v28/sutskever13.pdf#page=2" rel="noopener noreferrer">Sutskever i współautorzy, §2, równania 1–2</a>.</p>
<p><img src="https://paweldubiel.com/assets/momentum-flywheel-opposing-correction.webp" alt="Koło zamachowe z wygasającymi śladami obrotu i małą strzałką skierowaną przeciwnie, jako metafora ruchu podtrzymywanego przez wcześniejsze poprawki." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="dwie-poprawki-tej-samej-prognozy">Dwie poprawki tej samej prognozy</h2>
<p>Żeby policzyć przykład, oceniamy błąd jako <strong>połowę kwadratu różnicy</strong> między prognozą a 10. To własna, uproszczona funkcja straty: liczba, którą chcemy zmniejszać. Jej gradient wynosi <code>prognoza − 10</code>. Ujemny podpowiada zwiększenie prognozy, dodatni — zmniejszenie. Wielkość reakcji ustalamy współczynnikiem uczenia (<em>learning rate</em>) <code>0,2</code>.</p>
<p>Bez pamięci pierwszy krok daje <code>6 − 0,2 × (−4) = 6,8</code>. Drugi używa tylko nowego gradientu <code>−3,2</code>: wynik to <strong>7,44</strong>.</p>
<p>Z Momentum również zaczynamy od 6,8, lecz przy drugiej poprawce zachowujemy <code>80%</code> poprzedniego śladu. Nowy ślad to <code>0,8 × (−4) + (−3,2) = −6,4</code>, więc prognoza rośnie do <strong>8,08</strong>. Ta sama bieżąca wskazówka daje większą poprawkę dzięki historii. Nie oznacza to zapamiętywania wszystkich dostaw.</p>
<p>Oto stosowana reguła, zgodna z podstawowym wariantem w <a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.SGD.html#sgd" rel="noopener noreferrer">dokumentacji PyTorch 2.11 SGD, uwaga o Momentum</a>:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>b</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><mi>μ</mi><msub><mi>b</mi><mi>t</mi></msub><mo>+</mo><msub><mi>g</mi><mi>t</mi></msub><mo separator="true">,</mo><mspace width="2em"></mspace><msub><mi>w</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mo>=</mo><msub><mi>w</mi><mi>t</mi></msub><mo>−</mo><mi>η</mi><msub><mi>b</mi><mrow><mi>t</mi><mo>+</mo><mn>1</mn></mrow></msub><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">b_{t+1}=\mu b_t+g_t,\qquad w_{t+1}=w_t-\eta b_{t+1}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9028em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">μ</span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6389em;vertical-align:-0.2083em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:2em;"></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.9028em;vertical-align:-0.2083em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">η</span><span class="mord"><span class="mord mathnormal">b</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2083em;"><span></span></span></span></span></span></span><span class="mord">.</span></span></span></span></span>
<p><code>w</code> to prognoza, <code>g</code> — bieżący gradient, <code>b</code> — zapamiętany ślad, <code>t</code> — numer kroku. <code>μ</code> określa zachowaną część śladu, a <code>η</code> wielkość reakcji. Zaczynamy z <code>b=0</code>. Przy <code>μ=0</code> zostaje zwykła poprawka bez pamięci. Używamy stałego <code>η=0,2</code>, bez dodatkowych korekt algorytmu.</p>
<h2 id="dlaczego-pamięć-wymaga-ostrożności">Dlaczego pamięć wymaga ostrożności?</h2>
<p>W tym przykładzie Momentum szybciej zbliża prognozę do 10, ale w czwartym kroku przekracza cel: <strong>10,7168</strong>. Następny gradient podpowiada już zmniejszenie prognozy, lecz wcześniejszy ślad nadal ją zwiększa — do <strong>11,55648</strong>. Strata rośnie z około <strong>0,257 do 1,211</strong>. Pamięć może więc pomagać, a później opóźniać zmianę kierunku; nie gwarantuje poprawy po każdym kroku.</p>
<p>Przejdź kolejne kroki poniżej. Przy kroku 5 porównaj wskazówkę z faktycznym ruchem. Potem ustaw pamięć na zero: czy obie drogi się pokryją? Zmiana suwaka przelicza całą drogę od tego samego startu.</p>
<div id="momentum-steps-lab"></div>
<p>Model językowy ma wiele wag — liczb sterujących jego obliczeniami — i trudniejszą funkcję straty. Momentum może uzupełniać <a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">Stochastic Gradient Descent</a>, który wylicza wskazówki z części danych. Zachowany ślad należy do <a href="https://paweldubiel.com/glossary/optimizer-state">Optimizer State</a>, czyli pamięci algorytmu aktualizacji. <a href="https://paweldubiel.com/glossary/adam">Adam</a> także wykorzystuje historię kierunku, ale dodatkowo dostosowuje skalę reakcji osobno dla wag; jego reguła różni się od pokazanego Momentum.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/nesterov-momentum">Nesterov Momentum</a> — wariant sprawdzający gradient w przewidywanym punkcie po zachowanej części poprzedniego ruchu.</p>]]></content:encoded>
</item>
<item>
  <title>Stochastic Gradient Descent</title>
  <link>https://paweldubiel.com/glossary/stochastic-gradient-descent</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/stochastic-gradient-descent</guid>
  <pubDate>Thu, 01 Oct 2026 14:34:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz nauczyć prosty model przewidywania czasu dostawy. Na razie zawsze podaje 6 minut, a dwa zapisane przejazdy trwały 8 i 12 minut. Trzeba zmienić jego ustawienie.</description>
  <content:encoded><![CDATA[<p>Chcesz nauczyć prosty model przewidywania czasu dostawy. Na razie zawsze podaje 6 minut, a dwa zapisane przejazdy trwały 8 i 12 minut. Trzeba zmienić jego ustawienie. Można przed każdą poprawką sprawdzać wszystkie przejazdy. Przy dwóch to łatwe; przy milionach kolejne pełne przeliczenie opóźnia każdą zmianę.</p>
<p><strong>Stochastic Gradient Descent (SGD)</strong> wyznacza poprawkę na podstawie losowo wybranego przykładu, zamiast całego zbioru. W wariancie <strong>mini-batch SGD</strong> korzysta z małej grupy przykładów i uśrednia ich wskazówki (<a href="https://d2l.ai/chapter_optimization/minibatch-sgd.html#minibatches" rel="noopener noreferrer">D2L, §12.5.2</a>). Nie wybiera przypadkowego kierunku: losowe są dane użyte do jego obliczenia. Różnicę między pełnym obliczeniem a pojedynczą próbką opisuje <a href="https://leon.bottou.org/publications/pdf/compstat-2010.pdf#page=2" rel="noopener noreferrer">Léon Bottou, <em>Large-Scale Machine Learning with Stochastic Gradient Descent</em>, §2.1–2.2</a>.</p>
<p><img src="https://paweldubiel.com/assets/stochastic-gradient-descent-spoon-sample-bowl.webp" alt="Mała łyżka pobiera porcję z dużej miski różnobarwnych ziaren, pokazując wybór części danych do jednej poprawki modelu." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="jedna-poprawka-bez-przeglądania-wszystkiego">Jedna poprawka bez przeglądania wszystkiego</h2>
<p>W naszym uproszczeniu model ma jedną <strong>wagę</strong> — regulowaną liczbę, tutaj równą prognozie czasu. <strong>Strata</strong> to liczbowa ocena błędu. Przyjmijmy połowę kwadratu różnicy między prognozą a rzeczywistym czasem. Kwadrat sprawia, że duże pomyłki kosztują więcej.</p>
<p><strong>Gradient</strong> mówi, jak mała zmiana wagi wpływa na stratę. Dla tej straty to prognoza minus rzeczywisty czas. Znak podpowiada kierunek: ujemny gradient oznacza, że zwiększenie prognozy zmniejsza stratę tej próbki. <strong>Learning rate</strong> określa, jak mocno zastosujemy wskazówkę; wybieramy 0,2.</p>
<p>Jeśli wylosujemy przejazd trwający 8 minut, gradient wynosi <code>6 − 8 = −2</code>. Odejmujemy <code>0,2 × (−2)</code> od prognozy: dostajemy <strong>6,4 minuty</strong>. Gdyby trafiło na 12 minut, wynik wyniósłby <strong>7,2</strong>. Pełna średnia wskazówek z obu przejazdów dałaby <strong>6,8</strong>. To własne dane i rachunki, nie pomiar modelu językowego.</p>
<p>SGD pozwala zacząć aktualizację po przetworzeniu części danych. Przy równym losowaniu z tych dwóch przejazdów średnia możliwych gradientów odpowiada pełnemu gradientowi, choć pojedyncze kroki się różnią. Nie gwarantuje to krótszego całego treningu ani najlepszego rozwiązania.</p>
<h2 id="poprawa-próbki-może-pogorszyć-całość">Poprawa próbki może pogorszyć całość</h2>
<p>Ustawmy prognozę na <strong>10 minut</strong>: to najlepszy wspólny wynik dla naszych dwóch czasów i wybranej straty. Krok z próbki 8 minut zmieni ją na <strong>9,6</strong>. Strata tej próbki spadnie z 2 do 1,28, lecz średnia strata obu przejazdów wzrośnie z 2 do <strong>2,08</strong>. Pojedyncza próbka nie opisuje całego zbioru. Dobór wielkości kroków ma znaczenie; stały krok może podtrzymywać wahania wokół rozwiązania (<a href="https://leon.bottou.org/publications/pdf/compstat-2010.pdf#page=3" rel="noopener noreferrer">Bottou, §2.2</a>).</p>
<p>Wybierz poniżej porcję danych, potem punkt startu 10. Porównaj błąd porcji z błędem całego zbioru. Przyciski odsłaniają możliwe wyniki losowania; same <strong>nie losują</strong>. Każde ustawienie liczy jeden krok od wybranego startu, bez historii wcześniejszych kliknięć.</p>
<div id="sgd-sample-lab"></div>
<h2 id="jak-to-łączy-się-z-uczeniem-llm">Jak to łączy się z uczeniem LLM?</h2>
<p>Model językowy ma wiele wag i inną funkcję straty, np. <a href="https://paweldubiel.com/glossary/cross-entropy">Cross-entropy</a>, która ocenia szanse przypisane poprawnym kawałkom tekstu. Zasada aktualizacji z porcji danych pozostaje użyteczna, lecz SGD nie jest jedynym algorytmem. Oryginalny <a href="https://paweldubiel.com/glossary/transformer">Transformer</a> używał <a href="https://paweldubiel.com/glossary/adam">Adama</a> (<a href="https://arxiv.org/html/1706.03762v7#S5.SS3" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §5.3</a>).</p>
<p><a href="https://paweldubiel.com/glossary/gradient-accumulation">Gradient Accumulation</a> łączy wskazówki z kilku porcji <strong>przed</strong> jednym krokiem. Zwykły SGD nie zachowuje historii gradientów między krokami. Wariant z <strong><a href="https://paweldubiel.com/glossary/momentum">momentum</a></strong>, który podtrzymuje wpływ wcześniejszych wskazówek, potrzebuje już takiej pamięci — to część <a href="https://paweldubiel.com/glossary/optimizer-state">Optimizer State</a>, czyli dodatkowych danych przechowywanych przez algorytm aktualizacji wag (<a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.SGD.html#sgd" rel="noopener noreferrer">reguła i uwagi PyTorch 2.11 SGD</a>).</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/learning-rate-warmup">Learning Rate Warmup</a> — stopniowe zwiększanie learning rate na początku treningu.</p>]]></content:encoded>
</item>
<item>
  <title>Optimizer State</title>
  <link>https://paweldubiel.com/glossary/optimizer-state</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/optimizer-state</guid>
  <pubDate>Wed, 30 Sep 2026 19:40:46 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Przerywasz uczenie modelu i zapisujesz jego wagi — liczby sterujące obliczeniami. Jutro wczytujesz je i podajesz tę samą następną porcję danych.</description>
  <content:encoded><![CDATA[<p>Przerywasz uczenie modelu i zapisujesz jego wagi — liczby sterujące obliczeniami. Jutro wczytujesz je i podajesz tę samą następną porcję danych. Model zaczyna z tymi samymi ustawieniami, ale kolejna zmiana wag może być inna. Dlaczego? Algorytm uczenia mógł korzystać także z pamięci wcześniejszych zmian, której nie zapisałeś.</p>
<p><strong>Optimizer State</strong> to pomocnicze dane utrzymywane między krokami przez optymalizator, czyli algorytm wyznaczający aktualizacje wag. Mogą obejmować zapamiętane kierunki zmian, statystyki ich wielkości i licznik kroków. To odrębne dane od samych wag modelu.</p>
<p><img src="https://paweldubiel.com/assets/optimizer-state-suitcase-dial-memory-ribbon.webp" alt="Otwarta walizka z regulowanym pokrętłem i zwiniętą taśmą wcześniejszych ruchów, symbolizująca zapis ustawienia wraz z historią potrzebną do dalszego uczenia." loading="eager" decoding="async" width="1536" height="1024"></p>
<p>Wróćmy do przerwanego uczenia. Uprośćmy model do jednej wagi o wartości <code>1</code>. Gradient jest liczbą opisującą, jak zmiana tej wagi wpływa na błąd. Dodatni gradient podpowiada zmniejszenie wagi; ujemny — zwiększenie. Wybieramy algorytm z <a href="https://paweldubiel.com/glossary/momentum">momentum</a>: zachowuje on ślad poprzednich gradientów i łączy go z bieżącym. Nie przechowuje wszystkich dawnych przykładów.</p>
<p>Załóżmy, że zapamiętany ślad wynosi <code>1</code>, zachowujemy <code>80%</code> jego wartości, nowy gradient wynosi <code>1</code>, a wielkość kroku ustawiamy na <code>0,1</code>. Po odtworzeniu historii nowy ślad to <code>0,8 × 1 + 1 = 1,8</code>, więc waga spada do <code>1 − 0,1 × 1,8 = 0,82</code>. Po utracie historii ślad zaczyna od nowego gradientu, czyli <code>1</code>, a waga spada tylko do <code>0,9</code>. Te własne liczby ilustrują regułę z <a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.SGD.html#sgd" rel="noopener noreferrer">dokumentacji PyTorch 2.11 SGD, uwaga o momentum</a>. Stosujemy podstawowy wariant momentum, bez innych korekt aktualizacji.</p>
<h2 id="ile-historii-trzeba-przechowywać">Ile historii trzeba przechowywać?</h2>
<p><a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">SGD</a> (Stochastic Gradient Descent) zmienia wagi na podstawie gradientu bieżącej porcji danych. Dodanie momentum daje mu także pamięć wcześniejszych kroków.</p>





















<table><thead><tr><th>Algorytm</th><th>Pomocnicza pamięć związana z wagami</th></tr></thead><tbody><tr><td>Zwykły SGD bez momentum</td><td>Nie potrzebuje historii gradientów między krokami.</td></tr><tr><td>SGD z momentum</td><td>Jeden zapamiętany ślad na wagę.</td></tr><tr><td>Adam</td><td>Dwie statystyki na wagę: średnia gradientów i średnia ich kwadratów; dodatkowo licznik kroków.</td></tr></tbody></table>
<p><a href="https://paweldubiel.com/glossary/adam">Adam</a> wykorzystuje te statystyki do ustalania kolejnych zmian; opisuje je <a href="https://arxiv.org/pdf/1412.6980v9" rel="noopener noreferrer">praca Kingmy i Ba, §2–3 i algorytm 1</a>. Tabela opisuje podstawowe warianty, bez dodatkowych buforów implementacji.</p>
<p>W PyTorch zapis optymalizatora zawiera także ustawienia, np. wielkość kroku. Jego część <code>state</code> przechowuje dane pomocnicze przypisane do parametrów, czyli wag modelu, ale nie zapisuje samych parametrów. Rozdział opisuje <a href="https://docs.pytorch.org/docs/2.11/generated/torch.optim.Optimizer.state_dict.html" rel="noopener noreferrer">dokumentacja <code>Optimizer.state_dict</code></a>.</p>
<p><a href="https://paweldubiel.com/glossary/zero">ZeRO</a> dzieli tę pamięć między urządzenia. W analizowanej w nim recepturze <a href="https://paweldubiel.com/glossary/mixed-precision-training">Mixed Precision Training</a> do kategorii pamięci optymalizatora <a href="https://arxiv.org/html/1910.02054v3#S3.SS1" rel="noopener noreferrer">wliczono również kopię master (§3.1)</a>, czyli dokładniejszą kopię wag FP32. To liczby zapisane z większą precyzją, a nie historia gradientów; kategorie kosztu zależą od przyjętej receptury.</p>
<p>Do kontynuowania uczenia zapisujemy więc wagi <strong>i</strong> stan algorytmu. <a href="https://docs.pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-a-general-checkpoint-for-inference-and-or-resuming-training" rel="noopener noreferrer">Poradnik PyTorch, „Saving &#x26; Loading a General Checkpoint”</a> pokazuje oba zapisy. To nadal nie gwarantuje identycznego dalszego przebiegu: znaczenie mogą mieć także kolejność danych, losowania i harmonogram wielkości kroku. Stan optymalizatora rozwiązuje jeden konkretny brak, nie zastępuje całego zapisu treningu.</p>
<h2 id="co-zabierzesz-do-kolejnego-kroku">Co zabierzesz do kolejnego kroku?</h2>
<p>Poniższa próba zawsze startuje od wagi <code>1</code>. Wybierz zawartość zapisu, potem zmień nowy gradient. Sprawdź także <code>−0,5</code>: zachowany ślad może jeszcze zmniejszać wagę, mimo że sam bieżący gradient podpowiada jej zwiększenie. To demonstracja jednego kroku momentum, bez pomiaru jakości modelu.</p>
<div id="optimizer-state-restart-lab"></div>]]></content:encoded>
</item>
<item>
  <title>All-gather</title>
  <link>https://paweldubiel.com/glossary/all-gather</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/all-gather</guid>
  <pubDate>Tue, 29 Sep 2026 22:00:20 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Dane są podzielone między trzy urządzenia. Każde ma inny fragment, a następne obliczenie wymaga u każdego kompletu. Potrzebujesz zebrać wszystkie części, zachowując ich zawartość i ustaloną kolejność.</description>
  <content:encoded><![CDATA[<p>Dane są podzielone między trzy urządzenia. Każde ma inny fragment, a następne obliczenie wymaga u każdego kompletu. Potrzebujesz zebrać wszystkie części, zachowując ich zawartość i ustaloną kolejność.</p>
<p><strong>All-gather</strong> przekazuje fragmenty wszystkich uczestników tak, że każdy otrzymuje ich połączoną kopię. W opisywanym NCCL kolejność wynika z ranku, czyli numeru uczestnika w grupie komunikacyjnej.</p>
<p>Dla fragmentów <code>[1, 4]</code>, <code>[2, −1]</code> i <code>[3, 2]</code> każdy otrzyma <code>[1, 4, 2, −1, 3, 2]</code>. Dwie wartości <code>2</code> pozostają dwoma elementami. Operacja niczego nie sumuje, nie usuwa powtórzeń i nie sortuje liczb.</p>
<p>Zebranie kompletu wymaga komunikacji i pamięci na pełny wynik. <a href="https://paweldubiel.com/glossary/all-reduce">All-reduce</a> z sumą dałby zamiast tego <code>[6, 5]</code>. Po <a href="https://paweldubiel.com/glossary/reduce-scatter">Reduce-scatter</a> All-gather może odtworzyć cały już połączony wynik z jego części.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p>Jeśli trzy ranki wysyłają po dwie liczby, każdy otrzymuje sześć. Fragment ranku 0 jest pierwszy, ranku 1 drugi, ranku 2 trzeci. Taką semantykę określają <a href="https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/collectives.html#allgather" rel="noopener noreferrer">NCCL, sekcja AllGather</a> oraz <a href="https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/api/colls.html#ncclallgather" rel="noopener noreferrer">API ncclAllGather</a>: początek fragmentu ranku <code>i</code> ma offset <code>i × sendcount</code>.</p>
<p><img src="https://paweldubiel.com/assets/all-gather-three-complete-card-collections.webp" alt="Na trzech stojakach powtarza się ten sam uporządkowany zestaw osobnych kart z liściem, półksiężycem i falą." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="te-same-części-u-wszystkich">Te same części u wszystkich</h2>
<p>Własny przykład:</p>

























<table><thead><tr><th>Rank</th><th>Wysyłany fragment</th><th>Wynik na każdym ranku</th></tr></thead><tbody><tr><td>0</td><td>[1, 4]</td><td>[1, 4, 2, −1, 3, 2]</td></tr><tr><td>1</td><td>[2, −1]</td><td>[1, 4, 2, −1, 3, 2]</td></tr><tr><td>2</td><td>[3, 2]</td><td>[1, 4, 2, −1, 3, 2]</td></tr></tbody></table>
<p>Dwie wartości 2 pozostają dwoma elementami. <a href="https://paweldubiel.com/glossary/all-reduce">All-reduce</a> z sumą dałby zamiast tego [6, 5] — dwie sumy odpowiadających sobie pozycji.</p>
<p>W demonstracji karty A, B i C zachowują swoje dane. Zamień przypisanie ranków 0 i 2: wynik zmieni <strong>kolejność fragmentów</strong>, choć nie zmienisz żadnej liczby. To zmiana numeracji uczestników, nie symulacja fizycznej drogi przesyłania danych.</p>
<div id="all-gather-lab"></div>
<h2 id="co-umożliwia-a-czego-nie-robi">Co umożliwia, a czego nie robi</h2>
<p><a href="https://paweldubiel.com/glossary/reduce-scatter">Reduce-scatter</a> może zostawić na każdym ranku inny fragment zredukowanego bufora. All-gather zbiera te fragmenty; przy zgodnym podziale takie złożenie daje wynik All-reduce. Jeśli zbierasz surowe fragmenty, otrzymujesz surowe fragmenty — samo All-gather nie uzgadnia gradientów.</p>
<p>W <a href="https://paweldubiel.com/glossary/zero">ZeRO</a> jest potrzebne do zebrania rozdzielonych parametrów na czas obliczeń, co opisuje <a href="https://arxiv.org/html/1910.02054v3#S7.SS2.SSS2" rel="noopener noreferrer">§7.2.2 pracy Rajbhandari et al.</a>. Złożenie pełnego bufora chwilowo zwiększa pamięć odbiorcy. Operacja nie oznacza, że model stale przechowuje wszystkie parametry na każdym GPU.</p>
<p>W tym wariancie NCCL wszyscy wysyłają taką samą liczbę elementów tego samego typu. Równe rozmiary to warunek omawianego API; nie należy go bez sprawdzenia przenosić na warianty zbierające fragmenty o różnych długościach.</p>]]></content:encoded>
</item>
<item>
  <title>Reduce-scatter</title>
  <link>https://paweldubiel.com/glossary/reduce-scatter</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/reduce-scatter</guid>
  <pubDate>Tue, 29 Sep 2026 22:00:20 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Kilka urządzeń policzyło wkłady do tego samego wyniku. Chcesz je połączyć, ale każde urządzenie ma później odpowiadać tylko za część danych. Przechowywanie całej sumy u wszystkich byłoby niepotrzebne.</description>
  <content:encoded><![CDATA[<p>Kilka urządzeń policzyło wkłady do tego samego wyniku. Chcesz je połączyć, ale każde urządzenie ma później odpowiadać tylko za część danych. Przechowywanie całej sumy u wszystkich byłoby niepotrzebne.</p>
<p><strong>Reduce-scatter</strong> łączy odpowiadające sobie elementy wkładów i rozdziela wynik na fragmenty między uczestników. Przy sumowaniu każdy element zawiera wkład wszystkich, lecz każdy uczestnik dostaje wyłącznie przypisaną część.</p>
<p>Trzy listy długości sześć mogą po zsumowaniu dać sześć wartości. Przy równym podziale każde z trzech urządzeń otrzymuje dwie. Numer uczestnika grupy, zwany rankiem, określa przypisanie fragmentu.</p>
<p>To różni się od <a href="https://paweldubiel.com/glossary/all-reduce">All-reduce</a>, który daje każdemu pełny wynik. Suma nie jest średnią bez dodatkowego dzielenia. <a href="https://paweldubiel.com/glossary/all-gather">All-gather</a> może później zebrać rozdzielone części u każdego. Tabela i eksperyment pokazują wkłady bez ukrywania tego rozróżnienia.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p>W <a href="https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/collectives.html#reducescatter" rel="noopener noreferrer">NCCL, sekcji ReduceScatter</a>, fragmenty mają równy rozmiar i trafiają do uczestników według ranku. Dla trzech ranków i dwóch elementów wyniku na rank każdy bufor wejściowy ma sześć elementów. Ten związek opisuje parametr <code>recvcount</code> w <a href="https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/api/colls.html#ncclreducescatter" rel="noopener noreferrer">API ncclReduceScatter</a>.</p>
<p><img src="https://paweldubiel.com/assets/reduce-scatter-woven-band-three-fragments.webp" alt="Trzy fragmenty przeciętej tkaniny zawierają te same trzy barwy splecionych nici, lecz każdy leży osobno." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="cała-suma-ale-tylko-kawałek-dla-każdego">Cała suma, ale tylko kawałek dla każdego</h2>
<p>Własny przykład z trzema rankami:</p>

























<table><thead><tr><th>Rank</th><th>Wejście</th><th>Wynik Reduce-scatter z sumą</th></tr></thead><tbody><tr><td>0</td><td>[1, 2, 3, 4, 5, 6]</td><td>[111, 222]</td></tr><tr><td>1</td><td>[10, 20, 30, 40, 50, 60]</td><td>[333, 444]</td></tr><tr><td>2</td><td>[100, 200, 300, 400, 500, 600]</td><td>[555, 666]</td></tr></tbody></table>
<p>Pierwsza suma to 1 + 10 + 100 = 111. Rank 0 otrzymuje ją razem z drugą sumą; nie dostaje pozostałych czterech. To odróżnia Reduce-scatter od <a href="https://paweldubiel.com/glossary/all-reduce">All-reduce</a>, który pozostawia cały zredukowany bufor u każdego uczestnika. <strong>Suma nie jest średnią</strong>: uśrednienie wymaga dodatkowego dzielenia.</p>
<p>Zmień ostatnią liczbę ranku 2. Który fragment wyniku się zmieni? Następnie zbierz fragmenty przez <a href="https://paweldubiel.com/glossary/all-gather">All-gather</a>: otrzymasz pełną sumę na każdym ranku, bez powtórnego sumowania.</p>
<div id="reduce-scatter-lab"></div>
<h2 id="związek-z-treningiem">Związek z treningiem</h2>
<p>W <a href="https://paweldubiel.com/glossary/zero">ZeRO</a> podział gradientów pozwala każdemu procesowi aktualizować przydzielone parametry. <a href="https://arxiv.org/html/1910.02054v3#S7.SS2.SSS1" rel="noopener noreferrer">Praca ZeRO, §7.2.1</a>, opisuje redukcję gradientów do ich właścicieli, a następnie zebranie <strong>zaktualizowanych parametrów</strong>. Pomiędzy tymi operacjami zachodzi krok optymalizatora; demonstracja pokazuje prostsze złożenie dwóch kolektywów na niezmienionych fragmentach.</p>
<p>Równoważność Reduce-scatter → All-gather z All-reduce dotyczy wyniku przy zgodnym podziale i tej samej redukcji. Nie gwarantuje identycznego czasu ani konkretnej topologii komunikacji.</p>]]></content:encoded>
</item>
<item>
  <title>Meta-learning</title>
  <link>https://paweldubiel.com/glossary/meta-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/meta-learning</guid>
  <pubDate>Tue, 29 Sep 2026 21:36:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>training</category>
  <description>Model rozpoznaje odręczne litery, ale pismo kolejnej osoby wygląda inaczej. Masz tylko kilka jej przykładów.</description>
  <content:encoded><![CDATA[<p>Model rozpoznaje odręczne litery, ale pismo kolejnej osoby wygląda inaczej. Masz tylko kilka jej przykładów. Chcesz wykorzystać wcześniejszą naukę tak, żeby dostosowanie do nowego pisma nie wymagało zaczynania długiego treningu od zera.</p>
<p><strong>Meta-learning</strong> to uczenie sposobu adaptacji albo punktu startowego ułatwiającego adaptację. Oceniamy nie tylko wyjściową odpowiedź, lecz również wynik po wykorzystaniu informacji z nowego zadania.</p>
<p>W tym dydaktycznym przykładzie proces ma dwa poziomy. Wewnętrzny dostosowuje model do pisma jednej osoby na kilku literach. Zewnętrzny sprawdza wynik na jej pozostałych literach i wykorzystuje wiele takich zadań, żeby wykształcić lepszy sposób adaptacji. Przy nowej osobie stosujemy wyuczony sposób, a skuteczność znów oceniamy na przykładach niewykorzystanych do dostosowania. <a href="https://arxiv.org/abs/1703.03400" rel="noopener noreferrer">MAML, §2</a>, jest przykładem dotyczącym startowych parametrów; <a href="https://arxiv.org/html/2609.35738v1#S4" rel="noopener noreferrer">harness learning, §4</a>, dotyczy adaptacji programu organizującego pracę modelu.</p>
<p>Samo ręczne poprawianie systemu kilka razy nie jest jeszcze meta-learningiem. Trzeba wskazać, co wcześniejsze uczenie wykształciło i czy pomaga na nowych zadaniach. Do oceny potrzebne są przykłady oddzielone od tych użytych podczas adaptacji.</p>
<p>W <a href="https://paweldubiel.com/articles/model-uczony-pojedynczych-poprawek-rozwija-harness-na-nowym-benchmarku">artykule o harness learning</a> zmienia się kod <a href="https://paweldubiel.com/glossary/ai-harness">AI Harness</a>, a model proponujący poprawki był wcześniej uczony z ich wyników. To odróżnia mechanizm adaptacji od zwykłego zapisania nowego skryptu.</p>]]></content:encoded>
</item>
<item>
  <title>Adam</title>
  <link>https://paweldubiel.com/glossary/adam</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/adam</guid>
  <pubDate>Mon, 28 Sep 2026 08:18:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Model popełnia błędy i trzeba zmieniać jego wagi. Wskazówki z kolejnych grup danych wahają się, a różne wagi mogą otrzymywać wartości o różnej skali.</description>
  <content:encoded><![CDATA[<p>Model popełnia błędy i trzeba zmieniać jego wagi. Wskazówki z kolejnych grup danych wahają się, a różne wagi mogą otrzymywać wartości o różnej skali. Chcesz wykorzystać historię tych wskazówek, zamiast reagować wyłącznie na ostatnią.</p>
<p><strong>Adam</strong> to optymalizator, czyli algorytm wyliczający aktualizacje wag. Wagi są liczbami sterującymi obliczeniami. Gradient mówi, jak ich mała zmiana wpływa na stratę — liczbową ocenę błędu.</p>
<p>Dla każdej wagi Adam pamięta średnią kroczącą gradientów oraz średnią ich kwadratów. Pierwsza podtrzymuje informację o kierunku, druga pomaga dostosować skalę kroku. Nowsze obserwacje mają większy udział; algorytm uwzględnia też korektę początkowego obciążenia tych średnich.</p>
<p>To ułatwia prowadzenie treningu, ale nie gwarantuje znalezienia najlepszego rozwiązania. Dwie zapamiętane liczby na wagę zajmują dodatkową pamięć, którą <a href="https://paweldubiel.com/glossary/zero">ZeRO</a> może rozdzielać między urządzenia. Szczegóły obliczeń i ograniczenia opisano poniżej.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p>Najpierw model przetwarza przykłady, a funkcja straty, np. <a href="https://paweldubiel.com/glossary/cross-entropy">Cross-entropy</a>, mierzy błąd. Następnie obliczany jest <strong>gradient</strong>: informacja, jak mała zmiana każdej wagi wpływa na stratę. Adam korzysta z gradientów, żeby wyznaczyć aktualizację wag.</p>
<h2 id="co-adam-pamięta">Co Adam pamięta?</h2>
<p>Dla każdej wagi przechowuje dwie liczby:</p>
<ul>
<li><strong>Średnią kroczącą gradientów</strong> — zachowuje informację o kierunku zmian z poprzednich kroków. Nowsze gradienty mają większy udział niż starsze.</li>
<li><strong>Średnią kroczącą kwadratów gradientów</strong> — opisuje ich skalę bez względu na znak. Służy do dostosowania wielkości aktualizacji osobno dla każdej wagi.</li>
</ul>
<p>Są to estymaty pierwszego i drugiego momentu. Druga liczba nie jest zwykłą wariancją: algorytm uśrednia kwadraty gradientów bez odejmowania średniej. Adam koryguje też początkowe zaniżenie obu średnich wynikające z rozpoczęcia od zera. Mechanizm opisują <a href="https://arxiv.org/pdf/1412.6980" rel="noopener noreferrer">Kingma i Ba, §2–3 i algorytm 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/adam-two-moments-adjustable-compass.webp" alt="Cyrkiel z dwiema szpulami i śladami wcześniejszych ruchów jako metafora dwóch statystyk używanych przez Adama do wyznaczania kolejnego kroku." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="mały-przykład">Mały przykład</h2>
<p>Własne podstawienie do reguły Adama: po korekcie początkowego zaniżenia średnia gradientów wynosi 2, a średnia ich kwadratów 4. Adam dzieli 2 przez pierwiastek z 4, otrzymując 1. Przy współczynniku uczenia (<em>learning rate</em>) 0,001 odejmuje więc od wagi około 0,001. Waga 0,5 zmienia się na około 0,499. Pomijamy tu bardzo małą stałą dodawaną w mianowniku dla stabilności obliczeń.</p>
<p>Adam nadal wymaga dobrania współczynnika uczenia. Dostosowanie kroku do historii gradientów nie gwarantuje spadku błędu po każdej aktualizacji.</p>
<h2 id="dlaczego-pojawia-się-przy-zero">Dlaczego pojawia się przy ZeRO?</h2>
<p>Dwie statystyki na każdą z miliarda wag, zapisane jako liczby FP32 po 4 bajty, zajmują <strong>8 GB</strong> — jeszcze bez samych wag, gradientów i pozostałych danych treningu. To własny rachunek, z dziesiętnym GB.</p>
<p><a href="https://paweldubiel.com/glossary/zero">ZeRO</a> rozdziela między GPU m.in. te pomocnicze dane, czyli <a href="https://paweldubiel.com/glossary/optimizer-state">stan optymalizatora</a>. Adam określa sposób aktualizacji wag, a ZeRO organizuje przechowywanie i wymianę potrzebnych danych. W recepturze <a href="https://paweldubiel.com/glossary/mixed-precision-training">Mixed Precision Training</a> analizowanej w <a href="https://arxiv.org/html/1910.02054v3#S3.SS1" rel="noopener noreferrer">pracy ZeRO, §3.1</a> dochodzi jeszcze kopia wag FP32.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/adamw">AdamW</a> — wariant, który oddziela kurczenie wag od kroku wynikającego z danych.</p>]]></content:encoded>
</item>
<item>
  <title>bfloat16</title>
  <link>https://paweldubiel.com/glossary/bfloat16</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/bfloat16</guid>
  <pubDate>Sun, 27 Sep 2026 08:48:04 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz przechowywać liczby treningu w połowie miejsca zajmowanego przez format 32-bitowy. Potrzebujesz szerokiego zakresu bardzo małych i dużych wartości, ale możesz zaakceptować rzadszą siatkę…</description>
  <content:encoded><![CDATA[<p>Chcesz przechowywać liczby treningu w połowie miejsca zajmowanego przez format 32-bitowy. Potrzebujesz szerokiego zakresu bardzo małych i dużych wartości, ale możesz zaakceptować rzadszą siatkę dokładnych liczb między nimi.</p>
<p><strong>bfloat16 (BF16)</strong> to format 16-bitowy z zakresem rzędów wielkości zbliżonym do FP32, typowego formatu 32-bitowego, ale mniejszą precyzją zapisu. W porównaniu z innym formatem 16-bitowym, FP16, więcej bitów przeznacza na wykładnik — określający skalę liczby — kosztem szczegółów jej części znaczącej.</p>
<p>Na przykład <code>1,001</code> i <code>1,002</code> po zaokrągleniu do najbliższej liczby BF16 obie stają się <code>1</code>. Nie znaczy to, że format nie zapisze ogromnej wartości: zakres i dokładność są odrębnymi cechami.</p>
<p>BF16 różni się od FP16 mimo identycznej liczby bitów. Szerszy zakres bywa użyteczny w <a href="https://paweldubiel.com/glossary/mixed-precision-training">Mixed Precision Training</a>, lecz nie usuwa błędów zaokrągleń ani potrzeby dokładniejszych operacji w niektórych miejscach.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p><a href="https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus" rel="noopener noreferrer">Autorzy Cloud TPU opisują podział bitów w „Bfloat16 semantics”</a>. Dla porównania:</p>





























<table><thead><tr><th>Format</th><th>Bity znaku</th><th>Bity wykładnika</th><th>Bity części ułamkowej</th></tr></thead><tbody><tr><td>FP16</td><td>1</td><td>5</td><td>10</td></tr><tr><td>bfloat16</td><td>1</td><td>8</td><td>7</td></tr><tr><td>FP32</td><td>1</td><td>8</td><td>23</td></tr></tbody></table>
<p>Dla liczb normalnych dochodzi wiodąca jedynka niewpisywana do tych pól. Siedem zapisanych bitów daje więc osiem bitów precyzji znaczącej.</p>
<p><img src="https://paweldubiel.com/assets/bfloat16-wide-horizon-coarse-mosaic.webp" alt="Szeroki krajobraz z dużych pól mozaiki zestawiony z wąskim fragmentem o drobnym detalu." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="zasięg-nie-jest-dokładnością">Zasięg nie jest dokładnością</h2>
<p>Własny eksperyment: liczba <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>+</mo><msup><mn>2</mn><mrow><mo>−</mo><mn>10</mn></mrow></msup><mo>=</mo><mn>1,0009765625</mn></mrow><annotation encoding="application/x-tex">1+2^{-10}=1{,}0009765625</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">10</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">1</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">0009765625</span></span></span></span> mieści się dokładnie w FP16, lecz w BF16 zaokrągla się do 1. Najbliższa większa od 1 liczba BF16 to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>+</mo><msup><mn>2</mn><mrow><mo>−</mo><mn>7</mn></mrow></msup><mo>=</mo><mn>1,0078125</mn></mrow><annotation encoding="application/x-tex">1+2^{-7}=1{,}0078125</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">7</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">1</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">0078125</span></span></span></span>. Za to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mn>16</mn></msup><mo>=</mo><mn>65536</mn></mrow><annotation encoding="application/x-tex">2^{16}=65536</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">16</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">65536</span></span></span></span> przepełnia FP16, a BF16 zapisuje ją dokładnie. Mała <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mrow><mo>−</mo><mn>30</mn></mrow></msup></mrow><annotation encoding="application/x-tex">2^{-30}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">30</span></span></span></span></span></span></span></span></span></span></span></span> znika w FP16 do zera, lecz jest normalną liczbą BF16.</p>
<div id="bf-lab"></div>
<p>Dwie wartości mogą zatem zajmować po dwa bajty, a zachowywać się inaczej. BF16 nie jest „dokładniejszym FP16”. Oszczędność dotyczy reprezentowanych tensorów, nie automatycznie całej pamięci treningu.</p>
<p>W <a href="https://paweldubiel.com/glossary/mixed-precision-training">Mixed Precision Training</a> różne operacje mogą korzystać z różnych formatów. Cloud TPU mnoży wartości BF16, lecz sumuje iloczyny w FP32. <a href="https://docs.cloud.google.com/tpu/docs/bfloat16#format_conversion_details" rel="noopener noreferrer">Dokumentacja opisuje również konwersję</a>: zaokrąglanie do najbliższej wartości, przy remisie do parzystej; na TPU wartości subnormalne BF16 są zerowane. Tego zachowania sprzętu nie należy utożsamiać ze wszystkimi implementacjami formatu.</p>
<p>Szeroki zakres zmniejsza potrzebę <a href="https://paweldubiel.com/glossary/loss-scaling">Loss Scaling</a> znanego z FP16. Nie odzyskuje jednak szczegółu utraconego przez zaokrąglenie przy liczbie 1. Wybór formatu nadal wymaga sprawdzenia zachowania konkretnego modelu i operacji.</p>]]></content:encoded>
</item>
<item>
  <title>Gradient Clipping</title>
  <link>https://paweldubiel.com/glossary/gradient-clipping</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/gradient-clipping</guid>
  <pubDate>Sun, 27 Sep 2026 08:48:04 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Zwykle model wykonuje umiarkowane poprawki, ale czasem gradient staje się bardzo duży. Jeden krok może wtedy mocno zmienić wagi i rozchwiać trening.</description>
  <content:encoded><![CDATA[<p>Zwykle model wykonuje umiarkowane poprawki, ale czasem gradient staje się bardzo duży. Jeden krok może wtedy mocno zmienić wagi i rozchwiać trening. Potrzebujesz ograniczyć siłę takiej wskazówki przed aktualizacją.</p>
<p><strong>Gradient Clipping</strong> ogranicza gradient — listę liczb opisującą wpływ wag na błąd. W wariancie norm clipping skraca całą listę proporcjonalnie, jeśli jej długość przekracza ustalony próg. Kierunek pozostaje ten sam.</p>
<p>Lista <code>[6, 8]</code> ma długość <code>10</code>. Przy progu <code>5</code> dostajemy <code>[3, 4]</code>. To jak skrócenie strzałki bez jej obracania. Obcinanie każdej współrzędnej osobno jest innym wariantem i może zmienić kierunek.</p>
<p>Ograniczenie gradientu nie jest automatycznie tym samym ograniczeniem ostatecznego kroku każdego optymalizatora, np. <a href="https://paweldubiel.com/glossary/adam">Adama</a>. Nie rozwiązuje też zanikających gradientów. Przy <a href="https://paweldubiel.com/glossary/loss-scaling">Loss Scaling</a> kolejność odskalowania i clippingu ma znaczenie.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p>Dla gradientu <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>g</mi></mrow><annotation encoding="application/x-tex">g</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span></span></span></span>, normy euklidesowej <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">∥</mi><mi>g</mi><msub><mi mathvariant="normal">∥</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">\|g\|_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">∥</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord"><span class="mord">∥</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> i progu <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mo>></mo><mn>0</mn></mrow><annotation encoding="application/x-tex">c>0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5782em;vertical-align:-0.0391em;"></span><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mover accent="true"><mi>g</mi><mo stretchy="true">~</mo></mover><mo>=</mo><mrow><mo fence="true">{</mo><mtable rowspacing="0.36em" columnalign="left left" columnspacing="1em"><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>g</mi><mo separator="true">,</mo></mrow></mstyle></mtd><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi mathvariant="normal">∥</mi><mi>g</mi><msub><mi mathvariant="normal">∥</mi><mn>2</mn></msub><mo>≤</mo><mi>c</mi><mo separator="true">,</mo></mrow></mstyle></mtd></mtr><mtr><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi>c</mi><mtext> </mtext><mi>g</mi><mi mathvariant="normal">/</mi><mi mathvariant="normal">∥</mi><mi>g</mi><msub><mi mathvariant="normal">∥</mi><mn>2</mn></msub><mo separator="true">,</mo></mrow></mstyle></mtd><mtd><mstyle scriptlevel="0" displaystyle="false"><mrow><mi mathvariant="normal">∥</mi><mi>g</mi><msub><mi mathvariant="normal">∥</mi><mn>2</mn></msub><mo>></mo><mi>c</mi><mi mathvariant="normal">.</mi></mrow></mstyle></mtd></mtr></mtable></mrow></mrow><annotation encoding="application/x-tex">\widetilde g=\begin{cases}g,&#x26;\|g\|_2\leq c,\\c\,g/\|g\|_2,&#x26;\|g\|_2>c.\end{cases}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.885em;vertical-align:-0.1944em;"></span><span class="mord accent"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6906em;"><span style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span></span><span class="svg-align" style="width:calc(100% - 0.0556em);margin-left:0.0556em;top:-3.4306em;"><span class="pstrut" style="height:3em;"></span><span style="height:0.26em;"><svg xmlns="http://www.w3.org/2000/svg" width="100%" height="0.26em" viewBox="0 0 600 260" preserveAspectRatio="none"><path d="M200 55.538c-77 0-168 73.953-177 73.953-3 0-7
-2.175-9-5.437L2 97c-1-2-2-4-2-6 0-4 2-7 5-9l20-12C116 12 171 0 207 0c86 0
 114 68 191 68 78 0 168-68 177-68 4 0 7 2 9 5l12 19c1 2.175 2 4.35 2 6.525 0
 4.35-2 7.613-5 9.788l-19 13.05c-92 63.077-116.937 75.308-183 76.128
-68.267.847-113-73.952-191-73.952z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1944em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:3em;vertical-align:-1.25em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;"><span class="delimsizing size4">{</span></span><span class="mord"><span class="mtable"><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.69em;"><span style="top:-3.69em;"><span class="pstrut" style="height:3.008em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mpunct">,</span></span></span><span style="top:-2.25em;"><span class="pstrut" style="height:3.008em;"></span><span class="mord"><span class="mord mathnormal">c</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord">/∥</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord"><span class="mord">∥</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.19em;"><span></span></span></span></span></span><span class="arraycolsep" style="width:1em;"></span><span class="col-align-l"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.69em;"><span style="top:-3.69em;"><span class="pstrut" style="height:3.008em;"></span><span class="mord"><span class="mord">∥</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord"><span class="mord">∥</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mord mathnormal">c</span><span class="mpunct">,</span></span></span><span style="top:-2.25em;"><span class="pstrut" style="height:3.008em;"></span><span class="mord"><span class="mord">∥</span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mord"><span class="mord">∥</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mord mathnormal">c</span><span class="mord">.</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.19em;"><span></span></span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span>
<p><a href="https://arxiv.org/html/1211.5063v2#S3.SS2" rel="noopener noreferrer">Pascanu, Mikolov i Bengio, §3.2, algorytm 1</a> opisują tę strategię wobec gwałtownych wzrostów gradientu w RNN. Sam clipping nie rozwiązuje problemu zanikających gradientów.</p>
<p><img src="https://paweldubiel.com/assets/gradient-clipping-arrow-contained-circle.webp" alt="Krótka strzałka zachowuje kierunek dłuższej, lecz mieści się wewnątrz okrągłej granicy." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="skróć-strzałkę-zachowaj-kierunek">Skróć strzałkę, zachowaj kierunek</h2>
<p>Własny przykład: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>g</mi><mo>=</mo><mo stretchy="false">[</mo><mn>6</mn><mo separator="true">,</mo><mn>8</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">g=[6,8]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">6</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">8</span><span class="mclose">]</span></span></span></span> ma normę 10. Przy progu 5 otrzymujemy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>3</mn><mo separator="true">,</mo><mn>4</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[3,4]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">4</span><span class="mclose">]</span></span></span></span>. Dla zwykłego <a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">SGD</a> bez <a href="https://paweldubiel.com/glossary/momentum">momentum</a> i learning rate 0,1 krok <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mn>0,1</mn><mover accent="true"><mi>g</mi><mo stretchy="true">~</mo></mover></mrow><annotation encoding="application/x-tex">-0{,}1\widetilde g</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.885em;vertical-align:-0.1944em;"></span><span class="mord">−</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mord accent"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6906em;"><span style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span></span><span class="svg-align" style="width:calc(100% - 0.0556em);margin-left:0.0556em;top:-3.4306em;"><span class="pstrut" style="height:3em;"></span><span style="height:0.26em;"><svg xmlns="http://www.w3.org/2000/svg" width="100%" height="0.26em" viewBox="0 0 600 260" preserveAspectRatio="none"><path d="M200 55.538c-77 0-168 73.953-177 73.953-3 0-7
-2.175-9-5.437L2 97c-1-2-2-4-2-6 0-4 2-7 5-9l20-12C116 12 171 0 207 0c86 0
 114 68 191 68 78 0 168-68 177-68 4 0 7 2 9 5l12 19c1 2.175 2 4.35 2 6.525 0
 4.35-2 7.613-5 9.788l-19 13.05c-92 63.077-116.937 75.308-183 76.128
-68.267.847-113-73.952-191-73.952z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1944em;"><span></span></span></span></span></span></span></span></span> ma długość 0,5 zamiast 1. Tego ograniczenia długości kroku nie można automatycznie przenieść na <a href="https://paweldubiel.com/glossary/adam">Adam</a>, który przekształca gradient za pomocą własnego stanu.</p>
<p>Przycinanie każdej współrzędnej osobno do przedziału <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mo>−</mo><mn>5</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[-5,5]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">−</span><span class="mord">5</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">5</span><span class="mclose">]</span></span></span></span> daje natomiast <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>5</mn><mo separator="true">,</mo><mn>5</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[5,5]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">5</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">5</span><span class="mclose">]</span></span></span></span>: zmienia kierunek i pozostawia normę około 7,07. Oba warianty są użyteczne, lecz próg oznacza w nich coś innego.</p>
<div id="gc-lab"></div>
<p>W <a href="https://docs.pytorch.org/docs/2.11/generated/torch.nn.utils.clip_grad_norm_.html" rel="noopener noreferrer">PyTorch <code>clip_grad_norm_</code></a> norma obejmuje łącznie gradienty przekazanych parametrów. Liczenie osobnego limitu dla każdej warstwy da inne ograniczenie. Wartość NaN lub infinity wymaga diagnostyki; <code>error_if_nonfinite=True</code> pozwala jawnie zatrzymać taką aktualizację.</p>
<h2 id="kolejność-zmienia-wynik">Kolejność zmienia wynik</h2>
<p>Przy <a href="https://paweldubiel.com/glossary/loss-scaling">Loss Scaling</a> najpierw odskaluj gradienty, aby próg odnosił się do ich rzeczywistej wielkości. Przy <a href="https://paweldubiel.com/glossary/gradient-accumulation">Gradient Accumulation</a> zrób to po zebraniu całej efektywnej porcji, potem zastosuj clipping i krok. Taką kolejność podają <a href="https://docs.pytorch.org/docs/2.11/notes/amp_examples.html#gradient-clipping" rel="noopener noreferrer">przykłady AMP w PyTorch</a>.</p>
<p>Clipping jest nieliniowy. Dwa wkłady 10 i −9 sumują się do 1; przycięcie sumy do przedziału [−5,5] zachowa 1. Przycięcie wkładów osobno da 5 i −5, czyli sumę 0. To własny kontrprzykład pokazujący, dlaczego granica akumulacji ma znaczenie.</p>]]></content:encoded>
</item>
<item>
  <title>ZeRO</title>
  <link>https://paweldubiel.com/glossary/zero</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/zero</guid>
  <pubDate>Sun, 27 Sep 2026 08:48:04 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Uczysz model na kilku kartach. Każda przechowuje pełną kopię tych samych wag i pomocniczych danych treningu, więc część pamięci jest wielokrotnie zajęta przez identyczne informacje.</description>
  <content:encoded><![CDATA[<p>Uczysz model na kilku kartach. Każda przechowuje pełną kopię tych samych wag i pomocniczych danych treningu, więc część pamięci jest wielokrotnie zajęta przez identyczne informacje. Chcesz podzielić te dane bez zamiany pracy w kilka niezależnych treningów.</p>
<p><strong>ZeRO (Zero Redundancy Optimizer)</strong> rozdziela wybrane stany treningu między urządzenia. <a href="https://paweldubiel.com/glossary/optimizer-state">Stan optymalizatora</a> to pamiętane przez algorytm aktualizacji dane, np. średnie gradientów w <a href="https://paweldubiel.com/glossary/adam">Adamie</a>. Gradient opisuje wpływ wagi na błąd modelu.</p>
<p>ZeRO-1 dzieli stan optymalizatora. ZeRO-2 dodatkowo dzieli zredukowane gradienty, a ZeRO-3 także wagi. Potrzebne fragmenty są uzgadniane lub zbierane na czas odpowiednich obliczeń.</p>
<p>Zmniejszamy duplikowanie pamięci, ale dokładamy komunikację i organizację danych. ZeRO nie zastępuje Adama nową regułą wyznaczania poprawki ani nie daje automatycznej oszczędności całej pamięci w tej samej proporcji. Pozostają np. wyniki pośrednich obliczeń.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p>Przykładem takich pomocniczych danych są dwie statystyki gradientów zapamiętywane dla każdej wagi przez <a href="https://paweldubiel.com/glossary/adam">Adama</a> — algorytm obliczający, jak zmieniać wagi podczas nauki. Nazywamy je <strong>stanem optymalizatora</strong>. Adam określa sposób aktualizacji wag, a ZeRO pozwala rozdzielić potrzebne do niej dane między karty.</p>
<p>Trzy kolejne etapy obejmują coraz więcej danych:</p>
<ol>
<li><strong>ZeRO-1:</strong> dzieli stan optymalizatora.</li>
<li><strong>ZeRO-2:</strong> dodatkowo dzieli zredukowane gradienty.</li>
<li><strong>ZeRO-3:</strong> dodatkowo dzieli parametry modelu; potrzebne części są zbierane na czas obliczeń i ponownie rozdzielane.</li>
</ol>
<p>Tak definiuje etapy <a href="https://www.deepspeed.ai/tutorials/zero/#zero-overview" rel="noopener noreferrer">dokumentacja DeepSpeed</a>. Każdy obejmuje optymalizacje poprzedniego. Offload na CPU lub NVMe jest dodatkową możliwością, nie synonimem ZeRO-3.</p>
<p><img src="https://paweldubiel.com/assets/zero-shared-archive-divided-volumes.webp" alt="Cztery stanowiska przechowują różne części jednego kompletu ksiąg i wymieniają je wspólnym torem." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="co-właściwie-znika-z-pamięci">Co właściwie znika z pamięci?</h2>
<p>W recepturze <a href="https://paweldubiel.com/glossary/mixed-precision-training">Mixed Precision Training</a> z optymalizatorem Adam analizowanej przez <a href="https://arxiv.org/html/1910.02054v3#S5" rel="noopener noreferrer">Rajbhandari et al., §3.1 i §5</a>, na parametr przypada 16 bajtów: 2 na wagę FP16, 2 na gradient oraz 12 na kopię wagi FP32 i dwie statystyki gradientów przechowywane przez Adama. Przy <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotation encoding="application/x-tex">P</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span></span></span></span> parametrach i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>N</mi></mrow><annotation encoding="application/x-tex">N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.109em;">N</span></span></span></span> procesach idealny rozmiar przechowywanego stanu <strong>na proces</strong> wynosi:</p>

























<table><thead><tr><th>Wariant</th><th>Bajty na proces</th></tr></thead><tbody><tr><td>Pełne kopie</td><td><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>16</mn><mi>P</mi></mrow><annotation encoding="application/x-tex">16P</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord">16</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span></span></span></span></td></tr><tr><td>ZeRO-1</td><td><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi>P</mi><mo>+</mo><mn>12</mn><mi>P</mi><mi mathvariant="normal">/</mi><mi>N</mi></mrow><annotation encoding="application/x-tex">4P+12P/N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em;"></span><span class="mord">4</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">12</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mord">/</span><span class="mord mathnormal" style="margin-right:0.109em;">N</span></span></span></span></td></tr><tr><td>ZeRO-2</td><td><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>P</mi><mo>+</mo><mn>14</mn><mi>P</mi><mi mathvariant="normal">/</mi><mi>N</mi></mrow><annotation encoding="application/x-tex">2P+14P/N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">14</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mord">/</span><span class="mord mathnormal" style="margin-right:0.109em;">N</span></span></span></span></td></tr><tr><td>ZeRO-3</td><td><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>16</mn><mi>P</mi><mi mathvariant="normal">/</mi><mi>N</mi></mrow><annotation encoding="application/x-tex">16P/N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">16</span><span class="mord mathnormal" style="margin-right:0.1389em;">P</span><span class="mord">/</span><span class="mord mathnormal" style="margin-right:0.109em;">N</span></span></span></span></td></tr></tbody></table>
<p>Własne podstawienie: miliard parametrów i cztery GPU dają odpowiednio <strong>16, 7, 5,5 i 4 GB</strong> na GPU, przy dziesiętnym GB. Zwiększ liczbę GPU w demonstracji: w etapach 1 i 2 pozostaje część niedzielona.</p>
<div id="zero-lab"></div>
<p>Te liczby nie są szczytowym zużyciem VRAM. Nie obejmują aktywacji, buforów komunikacji ani chwilowego zebrania parametrów. <a href="https://paweldubiel.com/glossary/activation-checkpointing">Activation Checkpointing</a> ogranicza inną część rachunku — zapamiętane aktywacje.</p>
<p>Stan potrzebny do obliczeń trzeba dostarczyć. W analizie <a href="https://arxiv.org/html/1910.02054v3#S7" rel="noopener noreferrer">§7 pracy ZeRO</a> etapy 1–2 zachowują wolumen komunikacji bazowego DP, a etap 3 zwiększa go około 1,5 raza. To model komunikacji z konkretnymi założeniami, nie obietnica czasu treningu. Oszczędność pamięci i szybkość trzeba oceniać osobno.</p>
<p>Zobacz także: <a href="https://paweldubiel.com/glossary/reduce-scatter">Reduce-scatter</a> redukuje gradienty do przydzielonych fragmentów, a <a href="https://paweldubiel.com/glossary/all-gather">All-gather</a> zbiera rozdzielone parametry. Między redukcją gradientów a zebraniem zaktualizowanych parametrów zachodzi krok optymalizatora (§7.2.1 pracy ZeRO).</p>]]></content:encoded>
</item>
<item>
  <title>Gradient Accumulation</title>
  <link>https://paweldubiel.com/glossary/gradient-accumulation</link>
  <guid isPermaLink="true">https://paweldubiel.com/glossary/gradient-accumulation</guid>
  <pubDate>Fri, 25 Sep 2026 07:08:05 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Chcesz wyliczyć jedną poprawkę modelu na dużej grupie przykładów, ale cała grupa nie mieści się w pamięci. Możesz przetworzyć kilka małych porcji i połączyć ich wskazówki przed zmianą wag.</description>
  <content:encoded><![CDATA[<p>Chcesz wyliczyć jedną poprawkę modelu na dużej grupie przykładów, ale cała grupa nie mieści się w pamięci. Możesz przetworzyć kilka małych porcji i połączyć ich wskazówki przed zmianą wag.</p>
<p><strong>Gradient Accumulation</strong> zbiera gradienty, czyli informacje o wpływie wag na błąd, z kilku przebiegów. Wagi pozostają niezmienione do końca zbierania, a optymalizator — algorytm aktualizacji — wykonuje dopiero jeden wspólny krok.</p>
<p>Cztery równe porcje po osiem przykładów dają efektywną grupę 32. Żeby odpowiadać średniej dużej grupy, trzeba właściwie uśrednić wkłady. Przy nierównych porcjach znaczenie ma liczba ocenianych przykładów lub <a href="https://paweldubiel.com/glossary/token">tokenów</a>, czyli kawałków tekstu.</p>
<p>To nie jest to samo co cztery kolejne aktualizacje wag. Nie każda operacja modelu zachowuje się identycznie po podziale grupy, dlatego równoważność z jedną wielką porcją wymaga sprawdzenia założeń.</p>
<h2 id="mechanizm-i-szczegóły">Mechanizm i szczegóły</h2>
<p><img src="https://paweldubiel.com/assets/gradient-accumulation-reservoir-single-release.webp" alt="Małe strumienie napełniają jeden zbiornik z zamkniętym zaworem, obrazując zbieranie wkładów przed wspólną aktualizacją." loading="eager" decoding="async" width="1536" height="1024"></p>
<p>Przy równych porcjach po <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi></mrow><annotation encoding="application/x-tex">b</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">b</span></span></span></span> przykładów i <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span></span></span></span> przebiegach jeden krok obejmuje <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>k</mi></mrow><annotation encoding="application/x-tex">bk</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">bk</span></span></span></span> przykładów. Z <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> replikami <a href="https://paweldubiel.com/glossary/data-parallelism">Data Parallelism</a> jest to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>b</mi><mi>k</mi><mi>p</mi></mrow><annotation encoding="application/x-tex">bkp</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">bk</span><span class="mord mathnormal">p</span></span></span></span>, jeśli każda dostaje odrębne dane. Dokumentacja <a href="https://docs.pytorch.org/docs/2.11/notes/amp_examples.html#gradient-accumulation" rel="noopener noreferrer">PyTorch 2.11, Gradient accumulation</a> pokazuje dodawanie gradientów i aktualizację dopiero po całej porcji.</p>
<h2 id="średnia-musi-mieć-właściwy-mianownik">Średnia musi mieć właściwy mianownik</h2>
<p>Jeżeli <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>g</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">g_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7167em;vertical-align:-0.2861em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span></span></span></span> jest gradientem <strong>średniej</strong> straty z porcji liczącej <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>n</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">n_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7167em;vertical-align:-0.2861em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span></span></span></span> przykładów, gradient średniej po wszystkich przykładach wynosi:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>g</mi><mo>=</mo><munder><mo>∑</mo><mi>j</mi></munder><mfrac><msub><mi>n</mi><mi>j</mi></msub><mrow><munder><mo>∑</mo><mi>i</mi></munder><msub><mi>n</mi><mi>i</mi></msub></mrow></mfrac><msub><mi>g</mi><mi>j</mi></msub><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">g=\sum_j \frac{n_j}{\sum_i n_i}g_j.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.5213em;vertical-align:-1.4138em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.4138em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.1076em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.162em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2997em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.9857em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">g</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span><span class="mord">.</span></span></span></span></span>
<p>Dzielenie każdej straty przez liczbę porcji wystarcza przy równych rozmiarach. Przy nierównych trzeba uwzględnić liczebności. Dla <a href="https://paweldubiel.com/glossary/cross-entropy">Cross-entropy</a> uśrednianej po tokenach liczą się oceniane tokeny, również z uwzględnieniem <a href="https://paweldubiel.com/glossary/loss-masking">Loss masking</a>. To wynika z liniowości sumy i różniczkowania.</p>
<p>Własny przykład poniżej używa czterech celów <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mn>8</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,0,0,8]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">8</span><span class="mclose">]</span></span></span></span>, jednej wagi <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>w</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">w=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> i straty <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="normal">ℓ</mi><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo stretchy="false">(</mo><mi>w</mi><mo>−</mo><mi>y</mi><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">\ell=\frac12(w-y)^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord">ℓ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1901em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em;"><span style="top:-2.655em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.0641em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">y</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span>. Gradienty to <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mo>−</mo><mn>7</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[1,1,1,-7]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">−</span><span class="mord">7</span><span class="mclose">]</span></span></span></span>, więc średnia wynosi <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">−</span><span class="mord">1</span></span></span></span>. Jeden krok <a href="https://paweldubiel.com/glossary/stochastic-gradient-descent">SGD</a> z learning rate 0,25 daje <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>w</mi><mo>=</mo><mn>1,25</mn></mrow><annotation encoding="application/x-tex">w=1{,}25</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.0269em;">w</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">1</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">25</span></span></span></span>, niezależnie od podziału danych. Zobacz, co zepsuje podział 3+1 i zwykła średnia dwóch średnich.</p>
<div id="ga-lab"></div>
<p>Zgodność z dużym batchem zakłada tę samą funkcję straty i te same parametry podczas wszystkich przebiegów. Operacje zależne od całego batcha, losowość i zaokrąglenia mogą ją naruszyć. Wykonanie kroku optymalizatora po każdej porcji zmienia już sam algorytm.</p>
<p>Przy DDP można odroczyć synchronizację przez <code>no_sync()</code>. Kontekst musi obejmować również forward; pierwszy przebieg poza nim synchronizuje zgromadzone gradienty. Opisuje to <a href="https://docs.pytorch.org/docs/2.11/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.no_sync" rel="noopener noreferrer">dokumentacja DistributedDataParallel</a>.</p>]]></content:encoded>
</item>
</channel>
</rss>