Pretraining на LLM: данни, compute, scaling laws и цена

Нищо в целта не се променя. Моделът все още предсказва следващия token, loss-ът все още е cross-entropy от Глава 4, приложена към факторизацията от Глава 8, оптимизаторът все още е AdamW от Глава 6. Pretraining не е нов алгоритъм; това е същият алгоритъм, пуснат върху корпус, достатъчно голям, че run-ът трябва да се бюджетира. Две неща го правят възможно: labels са безплатни, защото целта за позиция $t$ е token-ът при $t+1$ и вече е в текста; а последният раздел на Глава 6 премахна възражението, защото модел с много повече параметри, отколкото класическите правила позволяват, не се разпада, а се подобрява. Резултатът е base model — нещо, което продължава текст, вместо да отговаря.

Преди всичко това да може да се бюджетира, трябва да се преброи, а областта го брои с една формула:

където $N$ е броят параметри, $D$ са training token, а $C$ са общите floating-point операции. Kaplan et al. я извеждат в две стъпки.¹ Forward: 2 FLOPs на параметър на token, защото всеки параметър в матрично умножение се използва веднъж на token, в едно умножение и едно събиране. Backward: два пъти forward, защото backward pass-ът от Глава 5 изчислява два gradient-а във всеки layer — спрямо inputs на layer-а, за да продължи сигналът да пътува, и спрямо неговите weights — всеки е матрично умножение с размера на forward, така че $4N$.

Това е цялото извеждане и си струва да се провери, вместо да се вярва. PyTorch идва с реален FLOP брояч, torch.utils.flop_counter.FlopCounterMode, който прихваща всяка операция, dispatch-ната от модела, и сумира реалната работа. Пуснете го през четири порядъка, най-големия върху meta device, който алокира shapes и никаква памет:

from torch.utils.flop_counter import FlopCounterMode

counter = FlopCounterMode(display=False)
with counter:                       
    loss = model(x, targets)[1]     
    loss.backward()                 
measured = counter.get_total_flops()
print(measured / (6 * n_params * n_tokens))

Съотношението forward+backward към forward е 3.000, точно, на всеки мащаб: не приближение, което случайно е добро, а аритметичната идентичност по-горе, върната като кръгло число от брояч, който не знае нищо за извеждането.

След това измерената обща стойност стои между 3% и 17% над $6ND$, след като $N$ брои embedding matrices — а тази уговорка има значение, защото двете основополагащи статии броят $N$ различно. Kaplan изключва „all vocabulary and positional embeddings“, защото така „produces significantly cleaner scaling laws“ (§1.3); Appendix F на Chinchilla казва „we also count embeddings matrices in the total parameter count“.² При широк vocabulary и тесен hidden dimension двете се различават с фактор девет, както показва първият ред.

Остатъчната разлика е това, което $6ND$ нарочно пропуска: attention scores. Eq. (2.2) на Kaplan записва forward cost като $2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ и маха втория член, защото $d_{\text{model}} \gg n_{\text{ctx}}/12$ — безопасно през 2020 г., по-малко безопасно сега, и причината съотношението да пълзи нагоре, когато $T/d$ расте — затова два реда тук споделят $T$ от 1 024 и съотношението пада, от 1.145 до 1.100, когато $d$ се качва от 768 на 1 600. Това е $O(T^2)$ cost, който Глава 9 въведе, а Глава 16 превръща в цена.

Compute решава колко дълго трае run-ът; паметта решава дали изобщо може да започне. Обучавайте с plain fp32 AdamW и всеки параметър носи четири числа: weight, неговия gradient и running mean $m$ и variance $v$ на Adam — двете средни, построени на ръка в Глава 6. Четири числа по четири байта са 16 байта на параметър, преди дори една activation. Измерено на 8 GB laptop GPU, като resident allocation е взета в точката от step-а, в която няма жив graph:

Прогнозата и измерването съвпадат в рамките на 3%. Изненадата е последната колона: activations смазват модела. Същият модел с 5,8 милиона параметъра, който се нуждае от 89 MB persistent state, се нуждае от 4 681 MB activations при batch 128 — петдесет и два пъти модела — и голяма част от това изобщо не е transformer-ът. Това са logits, един вектор с размер vocabulary за всеки token по четири байта на елемент: 512 MB в последния ред, 393 MB в първия. Размерът на vocabulary беше избран в Глава 7 и все още решава какво се побира на картата.

Кой член доминира зависи от формата на run-а, затова Micikevicius et al. казват, че паметта „is dominated by activations“³, докато ZeRO казва, че модел с 1,5 милиарда параметъра се нуждае от „at least 24 GB“ само за model states.⁴ ZeRO стига до същите 16 байта по друг път — $2\Psi$ за fp16 weights, $2\Psi$ за fp16 gradients, $4\Psi$ за fp32 master weights и двата moments на Adam — което за 70 милиарда параметъра е 1,12 терабайта, равни на четиринадесет 80 GB GPU още преди една activation.

Нищо от това не се побира на едно устройство при frontier scale, затова run-ът се разделя по четири начина едновременно. Data parallelism поставя копие на модела на всеки GPU и осреднява gradients — default-ът и този, който ZeRO подобрява, като отказва да държи излишни копия на optimizer state. Tensor parallelism разделя отделни матрици между устройства. Pipeline parallelism дава на всяко устройство непрекъсната група layers. Context parallelism разделя самата sequence, необходимо само когато $T$ е достатъчно дълго attention членът да доминира. Table 4 на Llama 3 изброява и четирите наведнъж: tensor 8, context до 16, pipeline 16, data до 128, върху 16 384 H100 GPU.⁵ Това е всичко, което този курс ще каже по темата; distributed training инженерството е отделен семестър, а Stanford CS336 е този семестър, лекции 5 до 8, с кода.⁶ След делегирането остава едно число, model FLOPs utilisation — частта от peak arithmetic на GPU, която реален run постига — и именно то превръща спретнатото $6ND$ в wall-clock време и следователно в пари.

През януари 2020 г. Kaplan et al. обучиха grid от transformers и откриха, че test loss следва power law във всеки от трите ресурса през повече от шест порядъка.¹ Техният §1.2 дава три fitted laws:

с придружители $\alpha_D \approx 0.095$ за данни и $\alpha_C^{\min} \approx 0.050$ за оптимално разпределен compute. Константите не са универсални, и статията го казва: „the precise numerical values of $N_c$, $C_c^{\min}$ and $D_c$ depend on the vocabulary size and tokenization and hence do not have a fundamental meaning.“

Експонентите са миниатюрни: десет пъти повече параметри купуват фактор $10^{0.076} \approx 1.19$ от оставащия loss. Това звучи като нищо, и е най-важният факт тук — възвръщаемостта е ужасна и никога не спира. Power law с малък експонент обещава, че следващият порядък ще помогне, по-малко от предишния, завинаги. Купуването на compute престава да бъде хазарт и става покупка с публикуван обменен курс, което е точно аргументът, отключил капитала.

После дойде предписанието, и тук статията сгреши по начин, който струваше на индустрията много пари. Table 6 на Kaplan дава $N_{\text{opt}} \propto C^{0.73}$ и $D_{\text{opt}} \propto C^{0.27}$: десет пъти повече compute означава модел 5,4 пъти по-голям, хранен само с 1,9 пъти повече текст. Abstract-ът е категоричен — „optimally compute-efficient training involves training very large models on a relatively modest amount of data and stopping significantly before convergence.“ Областта направи точно това: GPT-3 е 175 милиарда параметъра върху 300 милиарда token,⁷ Gopher 280 милиарда върху 300 милиарда, Megatron-Turing NLG 530 милиарда върху 270 милиарда.² Половин token до два token на параметър, навсякъде.

През март 2022 г. Hoffmann et al. обучиха над 400 модела от 70 милиона до 16 милиарда параметъра и стигнаха до обратното заключение по три независими пътя.² Тяхната Table 2 отчита експонента $a$ в $N_{\text{opt}} \propto C^{a}$ като 0.50, 0.49 и 0.46, срещу 0.73 на Kaplan. Казано просто: размерът на модела и training data трябва да растат в еднаква пропорция.

Вторият им подход е този, възпроизведен от sweep-а в началото на тази глава, на една милионна от мащаба: фиксирайте бюджет, обучете много размери точно с този бюджет, начертайте final loss спрямо размера на модела.

Held-out loss в nats на token, token на параметър в скоби, bold за най-добрия модел при всеки бюджет; тирето е точка, която не е пускана, защото бюджетът изисква повече текст, отколкото корпусът съдържа, или размерът е извън sweep-а там.

Четете надолу по колона: loss-ът пада, стига дъно и пак се качва. Един модел може да е твърде голям за бюджета си точно толкова лесно, колкото и твърде малък — при $10^{14}$ наказанието за избор на 665 280 параметъра вместо 295 808 е 0.08 nats, което по envelope-а, fitted по-горе, е loss-ът, който правилно оразмерен модел достига с 18% по-малко compute. Изборът на грешна форма изхвърля една пета от бюджета. Това е Figure 3 на Chinchilla за един следобед на един GPU вместо с четиристотин модела.

Сега четете напречно. При $10^{13}$ най-добрият модел е най-малкият в sweep-а; при $10^{14}$ е 295 808 параметъра, ограден от двете страни. Оптимумът се мести надясно с растежа на бюджета, което е цялото съдържание на корекцията. Fit-нете третия подход от статията — повърхността $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ върху всеки run — и минимизирайте при условие $C = 6ND$:

L(N, D) = 24.7 / N^0.195 + 46.8 / D^0.169       (E fits to ~0; see below)
implied   N_opt ∝ C^0.464
  compare   Chinchilla 0.46-0.50 · Besiroglu 0.513 · Kaplan 0.73

0.46, от laptop, срещу 0.73 на Kaplan. Съвпадение до три цифри от fit с три бюджета е късмет; съвпадение до първата не е. Експонентът пътува — константата не, защото token-to-parameter ratio при тези optima е 170 до 540, не 20. Три причини, всички поучителни. $E$ fit-ва до нула, защото при loss над 4 nats run-ът не е близо до entropy floor, който доминира fit-а на Chinchilla. Batch size и learning rate бяха фиксирани, вместо tuned за всяка точка, което ощетява run-овете с най-малко steps — а това са големите модели: при $10^{13}$ FLOPs модел с 1,28 милиона параметъра получава общо 159 optimizer steps, далеч под няколкото хиляди, които членът $S_{\min}$ на Kaplan казва, че всеки модел има нужда. Scaling law се fit-ва вътре в режим, а този стои шест порядъка под Chinchilla.

Оттук и abstract-ът на статията: „current large language models are significantly undertrained“. Chinchilla е демонстрацията — 70 милиарда параметъра върху 1,4 трилиона token, същият общ compute като Gopher с 280 милиарда върху 300 милиарда, побеждавайки го в 51 от 57 MMLU задачи, 67,5% срещу 60%.² Четири пъти по-малък, четири и половина пъти повече текст, същите пари, по-добър модел.

Две уговорки за това прочуто съотношение. „Двадесет token на параметър“ не е изречение в статията, която казва само, че „for every doubling of model size the number of training tokens should also be doubled“; 20 е извод от Table 3 и от собствените 70 B на Chinchilla върху 1,4 T. А точността му е по-лоша от публикуваното: Besiroglu et al. refit-наха от дигитализация на Figure 4, установиха, че оригиналните параметри „fit the reconstructed data poorly“ с интервали „implausibly tight given the number of data points“, и поставиха честния диапазон на „between 4 and 40“ token на параметър.⁸

Една подробност от метода на Chinchilla изпълнява обещание, което Глава 1 даде за learning-rate schedules. Cosine schedule трябва да е съобразен с token бюджета. Модел, който ще види 10 милиона token, трябва да decay-не learning rate до нула при 10 милиона token; дайте му schedule за 100 милиона, спрете го рано, и четете loss по средата на descent при твърде висок rate. Chinchilla обучава всеки модел при четири cycle lengths, за да контролира точно това; sweep-ът по-горе задава schedule-а си от бюджета по същата причина.

Те са най-полезният емпиричен резултат в областта и редовно се продават прекалено. Четири ограничения.

Те предсказват loss, не capability. Лявата страна е cross-entropy върху held-out text. Нищо в тези статии не разрешава твърдение дали модел ще пише правилен SQL, ще откаже вредна заявка или ще използва tool. Това отново е урокът от Глава 5: предсказание на loss-а не е предсказание на поведението, за което плащате.

Те са fitted, не derived. Няма теория, която произвежда $\alpha_N = 0.076$. Константите се местят с tokenizer-а — затова perplexity сравнение между два tokenizer-а е безсмислено, както обясни Глава 8 — и с data mixture, architecture и optimiser. Всяка публикувана law е law на setup-а, който я е произвел, затова Meta fit-на собствена преди Llama 3.⁵

Те предполагат fresh token за всеки step, което тихо предполага безкраен корпус. Muennighoff et al. измериха какво става, когато той свърши: до четири epochs повторени данни струват почти нищо — модел с 8,7 милиарда параметъра върху 44 милиарда unique token, видени четири пъти, завършва с „only 0.5 % higher validation loss“ от същия модел върху 178 милиарда unique — докато след около шестнадесет epochs допълнителният compute не купува нищо.⁹

И вече никой не обучава compute-optimal. Chinchilla минимизира цената на training; deployed модел след това плаща грубо $2N$ FLOPs на generated token, завинаги. LLaMA 1 го каза ясно: „given a target level of performance, the preferred model is not the fastest to train but the fastest at inference“.¹⁰ Sardana et al. го формализираха, като минимизираха $6ND_{\text{train}} + 2ND_{\text{inference}}$ вместо това, и установиха, че всеки, който очаква милиард заявки, трябва да обучава „smaller and longer than Chinchilla-optimal“.¹¹ §9.1 на Llama 3 е съгласен: малките му модели се обучават „far beyond the point of compute optimal training, effectively trading training compute for inference efficiency“.⁵ Съотношението не е остаряло; то отговаря на въпрос, който вече не е този, който се задава.

Loss-ът пада гладко. Benchmark scores понякога не. Wei et al. събраха случаи, в които задача стои на ниво chance през порядъци training compute и после скача — трицифрена аритметика, появяваща се в GPT-3 при около $2 \times 10^{22}$ FLOPs, MMLU, издигащ се над guessing между $3$ и $5 \times 10^{23}$ — и назоваха модела: „an ability is emergent if it is not present in smaller models but is present in larger models“.¹² Ако това е реално свойство, екстраполирането от евтини експерименти е опасно, защото capability, която купувате, може да не съществува в нито един мащаб, който можете да си позволите да тествате.

Schaeffer, Miranda and Koyejo твърдят, че по-голямата част е артефакт от измерването, а механизмът е аритметичен.¹³ Per-token loss пада гладко, така че вероятността един token да е правилен, $\exp(-\mathcal{L})$, се подобрява постепенно. Оценете модела с exact string match върху отговор от $L$ token и вдигате тази вероятност на степен $L$ — гладка крива, вдигната на голяма степен, изглежда като скала. Сменете метриката с такава, която брои token, вместо да изисква всички, върху същите outputs, и „the family's performance smoothly, continuously and predictably improves with increasing scale“.

Техният audit е числото за запомняне — „of the 39 preferred metrics in BIG-Bench, at most 5 display emergence“, като две прекъснати метрики обясняват над 92% от заявените случаи — и такава е и предпазливостта им: „nothing in this paper should be interpreted as claiming that large language models cannot display emergent abilities“. Скок в графика е доказателство за метриката, докато не се покаже друго. Глава 29 е мястото, където това става ваш проблем, защото изборът на hard-cutoff metric е решение, което ще вземете, без да забележите.

Корпусът е частта от pretraining run-а, към която няма закачено уравнение, и мястото, където живеят повечето решения с последствия. Суровината е web crawl: архивът на Common Crawl от август 2026 г. съдържа „2.14 billion web pages or 360 TiB of uncompressed content“, един месец от него, безплатен за download.¹⁴ Почти нищо не е използваемо както е. Статията T5 казва, че crawl-ът „largely comprises gibberish or boiler-plate text like menus, error messages, or duplicate text“, а C4 pipeline-ът, който въвежда, е списък от груби heuristics — пази само редове, завършващи с terminal punctuation, маха страници с по-малко от три изречения, маха всяка страница с curly brace или дума от публичен списък с obscenities — превръщайки двадесет терабайта месечен текст в около 750 GB.¹⁵

Груби е точната дума. Dodge et al. провериха какво премахват тези filters и откриха, че obscenity blocklist изтрива 42% от документи на African-American English и 32% на Hispanic-aligned English, срещу 6,2% от White-aligned English, оставяйки корпус 97,8% от последната категория.¹⁶ Правило без мнение за dialect се оказа с мнение.

После deduplication, което не е подреждане: Lee et al. откриват 61-word sentence, повторено 61 036 пъти в C4, и показват, че deduplicating намалява скоростта, с която моделите „emit memorized text“, десетократно, от 1,9% от generated token до 0,19%.¹⁷ Повече обаче не е по-добре — екипът на FineWeb deduplicate-на глобално през 96 crawls, получи 4 трилиона token и никаква измерима полза, после deduplicate-на всеки crawl отделно, получи 20 трилиона и изравни най-добрия съществуващ корпус.¹⁸

После contamination. Llama 3 измери своята и я публикува: 98% от AGIEval, 95% от BIG-Bench Hard и 85% от HellaSwag се припокриват с training set-а по 8-grams, а за MMLU overlap толкова висок, че „it is impossible to get a good performance gain estimate“.⁵ §4 на GPT-3 съобщава за filtering bug, оставил benchmarks в данните без път назад: „because of cost considerations it was infeasible to retrain the model“.⁷

Provenance е нерешената част. The Pile беше публикуван с компонент от 100,96 GiB, наречен Books3 — 12% от корпуса и, по собствената consent table на статията, книги от private torrent tracker;¹⁹ той беше свален offline през август 2023 г. след copyright complaint. Правната позиция към септември 2026 г. е неуредена, а трите американски решения, цитирани като тенденция, си противоречат. Alsup прие, че training върху законно придобити книги е „exceedingly transformative“, но постанови, че библиотека, построена от pirated copies, не е, и Anthropic уреди тази половина за $1.5 billion, покриващи 482 460 произведения, грубо $3 000 всяко, одобрено на 20 юли 2026 г.²⁰ Chhabria даде summary judgment на Meta, но написа, че решението му „does not stand for the proposition that Meta's use of copyrighted materials to train its language models is lawful“, а само че „these plaintiffs made the wrong arguments“.²¹ Bibas, отсъждайки срещу Ross Intelligence, отбеляза, че „only non-generative AI is before me today“.²² Нито един US appellate court не се е произнесъл по въпроса.

Хората вършат частите, които loss-ът не може. TIME съобщи през януари 2023 г., че работници, label-ващи toxic text за OpenAI чрез фирмата Sama, получават „between around $1.32 and $2 per hour“, докато четат пасажи, описващи child sexual abuse, torture and self-harm, докато OpenAI плаща на Sama $12.50 на час за работата; Sama оспорва както диапазона на заплащането, така и quota-та.²³ Това е filtering около pretraining, не самият pretraining — но е на същата фактура и е мястото, където стои човек.

Електричеството е реално и обикновено се цитира погрешно. Най-внимателната публикувана стойност е тази на BLOOM: 1 082 990 GPU-hours, 433 MWh и 24,7 tonnes CO₂ equivalent за run-а, 50,5 с manufacturing и idle nodes;²⁴ Patterson et al. поставят GPT-3 на 1 287 MWh и 552 tonnes.²⁵ Две предупреждения. Предимството на BLOOM е френската nuclear grid при 57 g CO₂ на kWh, не ефективност — той използва повече енергия от OPT-175B. А най-цитираната emissions стойност в областта, 626 155 lb на Strubell et al. за neural architecture search, по-късно беше показана като 88 пъти твърде висока, защото е приела, че search-ът е вървял на full model size, когато е вървял върху proxy.²⁶ Рамката на LBNL е защитимата: US data centres са използвали 192 TWh през 2024 г., 4,7% от националното електричество — число, прикачено към индустрия, не към отделен run.²⁷

Нишката през всичко това е това, което Bender et al. нарекоха documentation debt: „putting ourselves in a situation where the datasets are both undocumented and too large to document post hoc“.²⁸ Всеки факт по-горе съществува, защото някой е погледнал. За корпусите зад моделите, които повечето хора използват, никой не може.

Сега аритметиката, която всички искат, от четири цитирани inputs, така че когато остареят, да е ясно кое да се замени.

Четете последните две колони заедно. При $10 000 получавате модел с 5 милиарда параметъра на един нает node за две седмици. При $100 000 000 аритметиката казва 546 милиарда параметъра — и дванадесет хиляди H100, свързани за три месеца, което не е нещо, което наемате с кредитна карта. След около $100 000 обвързващото ограничение престава да е парите и става cluster-ът.

Преди да се доверите на такава таблица, тествайте я срещу run-ове, чиято реална цена е публикувана — llm.c възпроизвежда GPT-2 124M за „~90 minutes“ на 8×A100 node „for about $20“, и GPT-2 1.6B за 24 часа на 8×H100 node за $672.³¹

$672, against what $672 actually bought (llm.c GPT-2 1.6B, one 8xH100 node, 24 h)
  this table predicts:      168 H100-hours   N = 1.41 B params   D = 28.3 B tokens
  what was actually run:    192 H100-hours   N = 1.558 B params  D = 33.6 B tokens

Llama 3 405B, against Meta's own published GPU-hours
  from the paper's 3.8e25 FLOPs at 40 % MFU:   26.67 M H100-hours
  published in Meta's Llama 3.1 model card:    30.84 M H100-hours    ratio 0.86

И двете са в рамките на около 15%, което е приблизително точността, която такъв тип оценка заслужава, и значително по-добра от точността, с която обикновено се цитира.

Най-повтаряната цифра в тази тема е, че модел от клас GPT-2, струвал около $43 000 през 2019 г., днес може да се възпроизведе за няколко десетки долара. Съвременната половина е добре документирана; историческата не е.

Днес. README на nanochat на Karpathy: „you can train your own GPT-2 capability LLM ... for only $48 (~2 hours of 8XH100 GPU node) ... On a spot instance, the total cost can be closer to ~$15.“³² „GPT-2 capability“ тук е точно и публикувано — надминаване на CORE score на GPT-2 от 0.256525 — върху leaderboard, чийто най-добър запис към 14 март 2026 г. е 1,65 часа. $48 приемат $3 на GPU-hour, под list цената на Lambda от $3.99; по list е по-близо до $64.

През 2019. Няма primary source: OpenAI никога не публикува duration или cost. Веригата върви през The Register, февруари 2019 г., съобщаващ „256 Google TPU3 cores“ без цена и без duration; после Synced, юни 2019 г., отбелязващ, че hardware струва $256 на час в Google Cloud и изрично казващ, че „OpenAI didn't specify the training duration“. $43 008 са $256 на час по предполагаеми 168 часа, които никой никога не е sourced.

Така че честното заглавие е: модел, съответстващ на публикувания benchmark score на GPT-2, може да се обучи днес за доста под $100 върху нает hardware, срещу цена от 2019 г., която никога не е публикувана и чиято прочута оценка лежи върху неподкрепено предположение за duration. Сривът е реален и съвременната половина е възпроизводима от всеки с кредитна карта; ratio-то е аритметика върху число, което не съществува. Това е състоянието на публикуваните training costs като цяло. Статията GPT-3 не съдържа никаква dollar amount, само $3.14 \times 10^{23}$ FLOPs в Table D.1;⁷ статията Llama 3 също не съдържа такава.⁵ Всяка training cost, която сте чели, е estimate от FLOP count, hardware assumption и price assumption — винаги си струва да питате чие.

Резултатът е видял фиксиран корпус, събран в определен момент, и от това следват две свойства.

Първото е knowledge cutoff. След датата на събиране моделът не знае нищо — не „не е сигурен“, нищо — и ще confabulate-ва гладко, вместо да го каже, защото такова поведение никога не е било обучавано. Model card на Llama 3.1 дава декември 2023 г.;³³ всеки модел има такъв cutoff, и това е свойство на training data, не на deployment-а. Заобикалянето му е retrieval проблем, което е Глава 19.

Второто е, че base model довършва, вместо да отговаря. Дайте му „Коя е столицата на Франция?“ и правдоподобно продължение е друг въпрос, защото в корпуса този низ най-често се появява в списък с упражнения.

Text completer не е assistant. Той не следва instructions, защото нищо в корпуса не му е казало, че request трябва да бъде изпълнен, а не продължен. Няма понятие за conversation с двама участници. Ще произведе с охота най-вероятното продължение на вреден prompt, защото probable е единственото, за което някога е бил оптимизиран.

Превръщането му в нещо, което отговаря, изисква втори stage, струващ частица от процента от първия, и състоящ се почти изцяло в това да му покажете examples на желаното поведение и после да сравнявате двойки от собствените му outputs. Този stage е мястото, откъдето идват instruction following, chat templates, refusals и — това изненадва хората — способността да call-не tool. Глава 11 е този stage: supervised fine-tuning, RLHF, DPO и GRPO, и въпросът какво означава „aligned“ и кой решава.

Също си струва да се чете заедно с тази глава: build-nanogpt на Karpathy и придружаващото го video, които минават през пълно GPT-2 reproduction end to end с темпо, което тази глава не може да си позволи; и Stanford CS324, Large Language Models, чиито лекции за data и environmental impact навлизат по-дълбоко от раздела по-горе в материал, който този курс разглежда веднъж и делегира.