Chain of Thought, RLVR и Test-Time Compute — измерени

Изкушението е да кажем, че втората версия „е помислила“. Устоявайте му, защото механизмът е едновременно по-прост и по-полезен за разбиране.

Един transformer прави фиксирано количество изчисление за всеки генериран token. Един forward pass: същите слоеве, същите матрици, същият брой операции, независимо дали въпросът е колко е 2+2 или докажете тази теорема. В модела няма регулатор за „постарай се повече за това“.

Затова, когато моделът бъде помолен да даде отговор веднага, цялото налично изчисление за него е един forward pass. Всяка междинна величина трябва да се побере в активациите на този единствен pass, а всичко, което не може да изчисли там, не може да изчисли.

Извеждането на tokens променя това, и то по два различни начина, които си струва да се разграничат:

• Повече изчисление. Всеки генериран token е още един пълен forward pass. Сто четиридесет и пет tokens работа са сто четиридесет и пет пъти аритметиката на директния отговор.
• Външна памет. Tokens се записват в context, така че следващият pass може да ги прочете. 5 × 13 = 65 става факт във входа, а не стойност, която моделът трябва да държи в активация и да пренася напред. Моделът използва собствения си output като чернова.

Тази втора точка е тази, която хората пропускат, и тя обяснява защо работата трябва да бъде записана, за да помогне. Модел, помолен да „помисли наум и после да отговори“, няма къде да сложи мисълта.

Нищо от това не изисква мистика и води до ясна прогноза: chain of thought трябва да помага най-много при задачи със серийна структура — където стъпка две се нуждае от резултата от стъпка едно — и най-малко при задачи, които са единична справка. Точно това открива литературата и затова „мисли стъпка по стъпка“ не прави нищо за коя е столицата на Франция.

Техниката се появи през 2022 г. в две части. Wei и съавт. показаха, че включването на решени примери в prompt — демонстрации, при които отговорът е предшестван от разсъждение — носи големи подобрения в benchmarks за аритметика и здрав разум.¹ После Kojima и съавт. показаха нещо по-странно: примерите не са нужни. Добавянето на „Let's think step by step“ към zero-shot prompt улавя голяма част от същото подобрение.²

Вторият резултат е този, който показва какво се случва. Ако магическа фраза отключва поведението, поведението вече е било в модела — pretraining е пълен с решени примери, а фразата е указател към тази област от разпределението. Chain of thought не научи модела на нищо. Той избра нещо, което моделът вече имаше.

Тази рамка предсказва и бъдещото остаряване на техниката, към което се връщаме в края на главата.

Очевидната следваща стъпка: ако една верига на разсъждение може да е грешна, sample-нете няколко и вземете отговора с мнозинство. Това е self-consistency.³ Това е строго по-голям разход — $n$ пълни генерации вместо една — а интуицията е, че грешните отговори се разпръскват, докато верните съвпадат.

Измерено върху 16 от същите задачи, със sampling при temperature 0.8, гласуване с мнозинство върху $n$ вериги:

Шестнадесет задачи са малък знаменател и правилото от глава 4 важи за тази таблица толкова, колкото и за всяка друга. 13 от 16 е 81 % с 95 % Wilson интервал [57, 93]; 16 от 16 е 100 % с [81, 100]. Те се припокриват. Четете формата на кривата — това е находката; не четете точната степенка, където тя се изравнява, защото шестнадесет задачи не могат да я локализират.

Две неща има в тази таблица, а второто не беше това, което очаквах.

Кривата се изравнява при $n = 3$. До третия sample точността е на тавана си, а останалите два samples не купуват нищо, докато струват по 172 tokens всеки — 345 общо. Това е формата на всяка self-consistency крива, докладвана в литературата, и тя идва много по-рано, отколкото предполага рамката „повече samples е по-добре“.

А greedy decoding вече беше на 100 %. Върнете се към началото на главата: една верига, без sampling, 145 tokens, 24/24. Sampling при temperature 0.8 свали точността до 81 %, а self-consistency имаше нужда от три генерации, за да се върне там, където един-единствен greedy pass вече беше — при 3,6 пъти повече tokens, или шест пъти, ако пуснете sweep до пет, без да знаете къде се изравнява.

Това не е аргумент срещу self-consistency. То е точно описание на това какво прави: temperature купува разнообразие, като инжектира грешки, а гласуването премахва грешките, които току-що е инжектирало. При задачи, където greedy decoding се проваля — където единствената най-вероятна верига води на грешно място, а по-малко вероятна е вярна — тази размяна се изплаща и затова техниката съществува. При задачи, където greedy вече успява, това е начин да похарчите шест пъти бюджета, за да излезете на нула.

Никой не публикува втория случай, затова си струва да го измерите върху собствената си задача, преди да приемете техниката. Това са лесни двустъпкови задачи за малък модел; това е режимът, в който отговорът излиза така.

Всичко досега се случва по време на prompt върху модел, който никога не е бил специално обучаван за това. Промяната, която произведе сегашното поколение reasoning модели, беше да се премести това в обучението — а ключът, който го направи възможно, е по-тесен, отколкото звучи.

Post-training от глава 11 имаше нужда от човешки предпочитания, защото „това добър отговор ли беше?“ няма програмируем отговор. Но за някои въпроси има. Математическият отговор или е равен на правилната стойност, или не е. Кодът или минава тестовете, или не ги минава. Доказателството или се проверява, или не.

За тези домейни можете да замените reward model с verifier, и всичко надолу по веригата става по-добро наведнъж: без анотатори, без Bradley–Terry fitting, без reward hacking от вида, измерен в глава 11 — защото не можете да ласкаете unit test. Това е reinforcement learning from verifiable rewards, и това е средата, за която е създаден GRPO: sample-нете група опити за решение на един и същ проблем, проверете всеки и използвайте средната оценка на групата като baseline. Без critic, без анотатор, без reward model. Само програма, която казва вярно или грешно.

Резултатът, който пренареди областта, дойде от DeepSeek в началото на 2025 г.⁶ Те взеха базов модел и приложиха reinforcement learning with verifiable rewards директно, без преди това да има supervised fine-tuning етап — етапът, който глава 11 представя като основата на всичко. Дълги вериги на разсъждение се появиха въпреки това. Появиха се и поведения, които никой не беше обучавал: моделът започна да препроверява собствените си стъпки и, в най-цитирания пасаж от статията, спонтанно да преосмисля подход по средата на решението.

Честният прочит не е, че разсъждението е магия. А че когато единственото възнаграждавано нещо е да си прав, и да си прав при труден проблем изисква да го проработиш докрай, тогава проработването докрай е това, което оптимизаторът намира — включително частите от проработването, които правят и хората, защото те са това, което проблемът изисква, а не това, на което някой е учил модела.

Практическата последица от всичко това е, че reasoning модел произвежда tokens, които сте поискали, и tokens, които не сте, и плащате и за двата вида.

Доставчиците се справят с това различно, а разликата има значение:

• Повечето APIs броят reasoning tokens вътре в броя output tokens. Сметката ви и лимитът ви max_tokens включват мисленето, което никога не виждате.
• Gemini на Google отчита thinking tokens като отделно поле, извън стандартния output count.

Това е реална несъвместимост между два начина за броене на едно и също нещо, и всеки код, който изчислява цена или налага бюджет между доставчици, трябва да го нормализира. Глава 16 е мястото, където това става пари, а глава 23 — мястото, където става бюджет, който можете да наложите.

Другата последица е свързана с latency и изненадва хората първия път. Времето на reasoning модел до първия видим token включва цялото му мислене, така че заявка, която не stream-ва нищо осем секунди и после отговаря за една, не е увиснала връзка — моделът работи. Всеки интерфейс, който показва spinner без обяснение осем секунди, има дизайнерски проблем, не мрежов.

Заключително предупреждение, защото това е най-честият начин материалът от тази глава да бъде приложен погрешно.

Всичко в първата половина е техника за това модел, който не е обучаван да разсъждава, все пак да произвежда разсъждение. Моделите, обучени с RLVR, вече го правят: те извеждат собствената си работа, със собствената си дължина, преди да отговорят. Да кажете на такъв модел да мисли стъпка по стъпка е в най-добрия случай излишно, а в най-лошия вредно — може да произведе кратка, prompt-образна верига вместо по-дългата, която моделът би генерирал сам, и някои доставчици документират точно това.

Същото важи за сложни reasoning scaffolds, изградени в application code. Prompt, който превежда модел през decision tree, което той вече навигира вътрешно, харчи вашите tokens, за да ограничи поведение, което е било обучено вътре. Това е първата поява на тема, която минава през останалата част от курса: техники, които бяха съществени през 2022 г., станаха суеверие до 2025 г., а единственият начин да разберете кое кое е за вашия модел днес, е да измерите и двете.

Глава 15 е мястото, където това измерване става дисциплина, а не мнение.

Reasoning има неудобно свойство: това е единствената способност, чиято цена расте според това колко труден е въпросът. Модел, който мисли деветстотин tokens, прави деветстотин forward passes, държи нарастващ cache в паметта за всички тях и задържа GPU през цялото време.

Това прави икономиката на обслужване на reasoning модел рязко по-лоша от обслужването на chat модел и превръща набор от implementation details в разликата между жизнеспособен и нежизнеспособен продукт: как cache-ът на минали keys и values се съхранява и преизползва, колко заявки могат да споделят forward pass и колко precision всъщност са нужни на weights.

Глава 13 е последната, в която моделът е обект във вашата памет, а не услуга зад port, и е за това да направим този обект достатъчно евтин за обслужване. Тя също осребрява обещание от тази глава: speculative decoding, което произвежда няколко tokens приблизително на цената на един, като кара малък модел да отгатва, а голям да проверява — трик, който има смисъл едва след като сте видели колко голяма част от forward pass се изразходва в чакане на паметта, вместо в аритметика.

Всички измервания в тази глава идват от Qwen/Qwen2.5-0.5B-Instruct върху 24 генерирани текстови задачи в две стъпки, greedy decoding освен където е посочен sampling, с нула прекъснати генерации при използваните token caps. Те са възпроизводими и са малък модел върху лесни задачи: четете self-consistency резултата като демонстрация на механизма, не като benchmark. Глава 18 от лекционните бележки на CS229 и глава 12 от Hugging Face LLM Course покриват този материал с по-големи модели и истински benchmarks.