Fine-tuning, retrieval или prompt? Решает экономика

«Нужно ли нам fine-tune?» спрашивают так, будто это вопрос о модели. Это вопрос о бюджете, причем такой формы, на которую не отвечает ни один benchmark: за что платят один раз, за что платят за каждый вопрос и за что снова платят каждый раз, когда меняется мир.

Три маршрута — это также не три способа сделать одно и то же, и поставщики говорят об этом прямее, чем большинство блогов. Собственная таблица OpenAI о том, для чего supervised fine-tuning лучше всего подходит, перечисляет четыре применения: классификация, тонкий перевод, генерация контента в определенном формате и исправление сбоев в следовании инструкциям.¹ Среди них нет «научить модель тому, чего она не знает». Ее краткое описание выгоды такое: «вы можете использовать более короткие prompts с меньшим числом примеров и context data, что экономит token costs в масштабе и может снижать latency» — аргумент о счете, от компании, которая продает эту функцию.

Итак:

• Fine-tuning учит форме и поведению. Тону, формату, форме ответа, границе, которую можно показать, но трудно описать. Самая сильная опубликованная версия — Superficial Alignment Hypothesis из LIMA: знания приходят из pretraining, alignment в основном учит, в какой подраспределенной группе форматов говорить, — поэтому там хватило тысячи отобранных примеров.²
• Retrieval поставляет факты, которые меняются. Это единственный из трех вариантов, где правка вашей документации доходит до ответа без изменения модели.
• Prompting закрывает большинство реальных случаев и является честной базовой линией. In-context learning стал стандартом со времен Language Models are Few-Shot Learners: задача демонстрируется внутри prompt, и ни один weight не двигается.³

Две измерительные статьи закрывают дверь перед ошибкой посередине. Ovadia и коллеги сравнили внедрение знаний через unsupervised fine-tuning с внедрением через retrieval, и retrieval стабильно победил, включая факты, которые базовая модель уже видела на pretraining.⁴ Gekhman и коллеги измерили ущерб: примеры, которые вводят новые знания, подгоняются медленно, и когда модель наконец подгоняет их, ее уровень hallucination по другим вопросам растет.⁵ Учить факты через fine-tuning не просто не получается; это ухудшает ответы, на которых вы не обучались.

С этой половиной все решено. С экономической — нет, и ей посвящена остальная часть главы.

Один случай, три маршрута: техническая поддержка по вашей собственной документации, которая меняется каждую неделю.

Корпус реальный и лежит на этом диске: 23 Markdown-документа, которые один рабочий программный репозиторий хранит как внутреннюю документацию — руководство по сборке, правила бренда, translation brief, десять сервисных инструкций, заметки о производительности и безопасности. Измерено с помощью o200k_base, encoding из Главы 7:

documents                              23
characters                        159,223
words                              22,194
tokens (o200k_base)                42,921
tokens with per-file headers       43,158

Сорок три тысячи tokens — удобный размер для такого решения: он помещается в любой современный context window, так что все три маршрута действительно доступны. При десяти миллионах решение принято за вас, и это retrieval.

Теперь работа, которую делает слово «еженедельно». Обычно текучесть документации просто утверждают; здесь она посчитана по истории версий этого репозитория:

Документы движутся примерно через неделю. Видимые пользователю строки — а именно о них на самом деле спрашивают службу поддержки — менялись каждую неделю своего существования, примерно по двадцать commits в неделю. Какой бы маршрут мы ни выбрали, он должен это пережить, и «как часто меняется то, на чем вы обучались?» оказывается числом в вашем собственном репозитории, а не мнением.

Двадцать реалистичных вопросов поддержки были написаны по этому корпусу, по одному на тему, и все цифры ниже вычислены по этим двадцати.

Самое простое, что работает: положить весь корпус в system prompt, вопрос в конец и дать модели найти ответ.

system instructions                       140 tokens
the 23 documents                       43,158 tokens
the question (median of 20 measured)       13 tokens
the answer (the one assumption)           150 tokens

Все числа там были посчитаны, кроме последнего: 150 output tokens — это допущение, выбранное внутри диапазона turns assistant, которые тарифицировала Глава 16. Это единственная цифра здесь, которая не была исполнена, она применяется одинаково ко всем трем маршрутам, а раздел break-even точно показывает, насколько сдвигается вывод, когда вы ее меняете.

По ставкам, прочитанным со страницы поставщика 7 сентября 2026 года — $1.50 за миллион input tokens, $9.00 за миллион output⁶ — это $0.066317 за вопрос. Вы платите за повторное чтение сорока трех тысяч tokens, чтобы ответить на тринадцать.

Исправление из Главы 16 применяется напрямую: корпус стабилен и стоит впереди, значит это идеальный cache prefix, а повторное чтение стоит одну десятую — $0.007864 за вопрос, сокращение на 88 %. Предупреждение Главы 16 тоже применимо, в форме, которую та глава отметила, но не оценила. Этот поставщик не берет надбавку за запись; он берет аренду. Explicit cache стоит $0.000001 за сохраненный token в час,⁶ поэтому поддерживать 43,298 tokens теплыми стоит

независимо от того, задает ли кто-нибудь вопросы. Это $189.78 за шесть месяцев, за пустую комнату. Разделите аренду на экономию на вопросе, и условие получается в одну строку: caching этого корпуса окупается выше 0,74 вопроса в час — 546 в месяц, если учесть еще и еженедельную перестройку cache. Ниже этой отметки функция, которую вы включили ради экономии, теряет деньги.

Тот же маршрут, тот же код, один флаг, счет в пять раз выше. Глава 16 нашла версию этой проблемы, вызванную timestamp не в том месте; здесь ничего не сломано, кроме трафика. Cache — это ставка на объем, и у этого поставщика вы делаете ее по часам.

Retriever из Главы 19 без изменений: резать по границам разделов с контекстным заголовком, индексировать, класть в prompt четыре лучших фрагмента. Измерено по двадцати вопросам:

chunks produced from the corpus              330
mean tokens of a chunk's own text          124.9
mean tokens of the four retrieved extracts   884
prompt per question (140 + 884 + 13)       1,037
one-off embedding of every chunk        46,823 tokens

В сорок два раза меньше prompt tokens, чем в первом маршруте, при $0.002906 за вопрос. Индекс стоит $0.0070 построить при $0.15 за миллион embedding tokens⁶ — меньше трех вопросов — и те же $0.0070 на полную перестройку каждый раз, когда меняется документация. Полная еженедельная перестройка индекса в течение шести месяцев стоит восемнадцать центов.

На одном стоит остановиться. Retrieval уничтожает prompt caching. Стабильный префикс теперь — 140-token системная инструкция; с token 141 prompt различается в каждом вызове, потому что фрагменты выбираются под вопрос. А 140 tokens ниже любого минимума cache, который цитировала Глава 16. Поэтому второй маршрут вообще нельзя кэшировать, что звучит плохо, но плохо не является: не кэшировать 1,037 tokens дешевле, чем кэшировать 43,298.

Это общее правило, которое стоит унести с собой: две большие техники экономии tokens взаимоисключают друг друга на одном и том же содержимом, и выигрывает та, которая удаляет больше tokens. Retrieval удаляет 97,6 %.

Обучить на двухстах примерах в фирменном стиле, затем задавать вопросы вообще без приложенной документации.

training examples                            200
training tokens                           24,389
epochs                                         3
prompt per question (15 + 13)                 28

Обучение стоит 24,389 × 3 × $10.00 за миллион = $0.7317. Это вся стоимость строительства, меньше чашки кофе, и именно поэтому так много команд платят ее до проверки, помогает ли это.

Теперь ловушка, и именно ради нее существует эта глава. Fine-tuned модель не стоит при запуске столько же, сколько ее базовая модель. Страница pricing говорит об этом одним предложением: «for model inference starting from Gemini 3, tuned model endpoint prediction price will be 1.5 times of the base model».⁶ Не обучение. Inference, на каждом token, все время жизни модели.

Значит, запишем формулу. Пусть $p_i$ и $p_o$ — базовые цены input и output, $m$ — multiplier tuned модели, $L_R$ — длина prompt маршрута, который вы заменяете, $L_F$ — длина prompt после fine-tuning, а $O$ — длина ответа. Fine-tuning дешевле за вопрос только когда

Первый член очевиден: ваш новый короткий prompt с надбавкой. Второй — нет, и именно туда уходят деньги: надбавка на ответ, которая никак не связана с вашим prompt и которую обучение не может укоротить. С измеренными числами — $m = 1.5$, $L_F = 28$, $O = 150$, $p_o/p_i = 6$ — порог равен

answer   50 tokens -> the prompt it replaces must exceed   192 tokens
answer  150 tokens -> the prompt it replaces must exceed   492 tokens
answer  400 tokens -> the prompt it replaces must exceed 1,242 tokens
answer 1000 tokens -> the prompt it replaces must exceed 3,042 tokens

При измеренной длине ответа это 492 tokens — из них 450 приходятся на надбавку за ответ, а не на prompt. Замена более короткого prompt навсегда дороже за вопрос при любом объеме; и порог линейно растет с тем, сколько говорит ваш assistant, так что assistant, который пишет длинные ответы, никогда не сможет через fine-tuning прийти к более дешевому token, сколько бы prompt он ни удалил.

Та же истина с другой стороны — фраза, которую нужно запомнить. Из $0.002088 за вопрос у fine-tuned маршрута 97,0 % приходится на ответ. Fine-tuning оптимизирует оставшиеся три процента.

Четыре числа описывают любой из этих маршрутов: что вы платите один раз, что платите при изменении документации, что платите каждый час независимо ни от чего и что платите за вопрос. Это расширяет computeCost из Главы 16, не меняя ее.

import { computeCost, type Pricing, type Usage } from "./cost";   // Chapter 16

export interface Route {
  name: string;
  setupUSD: number;            // paid once, before the first question
  perRefreshUSD: number;       // paid every time the documentation changes
  standingUSDPerHour: number;  // paid per hour whatever the traffic
  pricing: Pricing;
  usage: Usage;                // one question and its answer
}

export const perQueryUSD = (r: Route) => computeCost(r.pricing, r.usage);

const HOURS_PER_MONTH = (24 * 365.25) / 12;

export function totalUSD(
  r: Route, months: number, queriesPerMonth: number, refreshesPerMonth: number,
) {
  return r.setupUSD
       + months * refreshesPerMonth * r.perRefreshUSD
       + months * HOURS_PER_MONTH * r.standingUSDPerHour
       + months * queriesPerMonth * perQueryUSD(r);
}

/** Monthly volume at which `b` overtakes `a`. null = it never does. */
export function crossover(
  a: Route, b: Route, months: number, refreshesPerMonth: number,
): number | null {
  const fixed = (r: Route) =>
      r.setupUSD
    + months * refreshesPerMonth * r.perRefreshUSD
    + months * HOURS_PER_MONTH * r.standingUSDPerHour;
  const dFixed = fixed(b) - fixed(a);                     // b's extra fixed cost
  const dVar = perQueryUSD(a) - perQueryUSD(b);           // b's per-question saving
  if (dVar <= 0) return null;                             // b is never cheaper
  return Math.max(0, dFixed / dVar / months);
}

Tuned модель — это не другой прайс-лист, а тот же самый, умноженный:

const TUNED_MULTIPLIER = 1.5;   // read from the provider's pricing page, 2026-09-07

const scale = (p: Pricing, k: number): Pricing => ({
  input: p.input.map(t => ({ ...t, price: t.price * k })),
  cachedInput: p.cachedInput!.map(t => ({ ...t, price: t.price * k })),
  output: p.output.map(t => ({ ...t, price: t.price * k })),   
});

Одна выделенная строка — весь аргумент предыдущего раздела, записанный как код: multiplier попадает и на output.

Шесть месяцев, с еженедельным обновлением документации:

И точки пересечения, то есть четыре числа, которые действительно нужны бюджету:

retrieval -> fine-tune, documentation never changes:     148 questions / month
retrieval -> fine-tune, documentation refreshed weekly: 3,989 questions / month
prompt (no cache) -> retrieval:                            1 question / month
prompt (no cache) -> prompt (cached):                    546 questions / month

Читайте первые два вместе, потому что это смысл главы. Неподвижный корпус заставляет fine-tuning окупиться за сто пятьдесят вопросов; корпус, который меняется еженедельно, сдвигает ту же точку пересечения в двадцать семь раз, и в модели ничего не изменилось — изменилось только то, как часто вы снова за нее платите. Стоимость строительства — сноска; стоимость обслуживания — решение.

Если теперь вы заключаете, что загруженная служба поддержки должна fine-tune, арифметика с вами согласна. Это все равно неверно, и следующий раздел объясняет почему.

У таблицы затрат есть один столбец, который она не может посчитать, поэтому этот раздел запускает fine-tune: локально, на небольшой open model, с adapter, написанным вручную, а не взятым из библиотеки. Глава 11 построила LoRA; здесь она на q_proj и v_proj всех 24 слоев Qwen2.5-0.5B-Instruct с rank 8:

class LoRALinear(nn.Module):
    def __init__(self, base: nn.Linear, r=8, alpha=16):
        super().__init__(); self.base = base
        for p in self.base.parameters():
            p.requires_grad = False              # the model is frozen  
        self.A = nn.Parameter(torch.zeros(r, base.in_features))
        nn.init.normal_(self.A, std=1 / r)
        self.B = nn.Parameter(torch.zeros(base.out_features, r))
        self.s = alpha / r
        self.on = True                           # so the same run can compare both

    def forward(self, x):
        y = self.base(x)
        return y + (x @ self.A.T @ self.B.T) * self.s if self.on else y

Двести обучающих примеров механически берутся из корпуса, поэтому они воспроизводимы: вопрос — это заголовок раздела, превращенный в вопрос, ответ — собственный текст этого раздела в жестком фирменном стиле: одна строка, начинающаяся с Short answer:, одна строка, начинающаяся с Source:, с путем к файлу. Формат — это форма, которой учат; путь — это факт. Затем два числа по двадцати отложенным вопросам: выходит ли ответ в фирменном стиле и называет ли он файл, который действительно отвечает на вопрос?

Две базовые линии делают таблицу читаемой, и обе — требование Главы 4, а не поздняя мысль. Десять из двадцати правильных ответов — один и тот же файл, поэтому модель, которая игнорирует вопрос и всегда отвечает CLAUDE.md, получает 10/20. И у retriever есть собственный потолок: по этим двадцати вопросам его четыре фрагмента содержат правильный файл 14 раз и ставят его первым 7 раз, так что 14/20 — максимум, который мог бы получить любой reader с его использованием.

LoRA modules 48   trainable parameters 540,672 (0.109 % of the model)
400 steps, 2 epochs, 0.76 s/step on 16 CPU threads, 304 s in total
mean loss over the first 50 steps 3.7363 -> over the last 50 steps 2.4197

                                        house style   correct source
always answer the most common file             --          10 / 20
the retriever's own ceiling                    --          14 / 20
base model, closed book                    0 / 20           0 / 20
fine-tuned, closed book                   19 / 20           8 / 20
base model, four retrieved extracts       13 / 20           2 / 20
fine-tuned, four retrieved extracts        1 / 20           1 / 20

Форма была выучена, полностью и быстро. С нуля до девятнадцати из двадцати, adapter на 540,672 параметрах — 0,109 % модели — за пять минут обучения на процессоре без видеокарты в поле зрения.

Факты — нет. Восемь из двадцати неотличимы от десяти, которые вы получаете, полностью игнорируя вопрос, и интервал Главы 4 на двадцати samples говорит об этом вслух. Эти пути к файлам были в обучающих данных три раза; на выходе получилась привычка заканчивать правдоподобно выглядящей строкой Source:. На вопрос из начала этой главы fine-tuned модель ответила Short answer: 10.x . . . и сослалась на CLAUDE.md. Правильный ответ, который находится в CLAUDE.md, — 18.17.0.

А затем форма сломалась, и именно эта строка оправдывает эксперимент. Дайте fine-tuned модели тысячу tokens найденных фрагментов — форму prompt, которую она никогда не видела, потому что каждый обучающий prompt был длиной двадцать восемь tokens, — и фирменный стиль падает с 19/20 до 1/20. На вопрос из начала этой главы она отвечает 18.17.0 — правильно, но без какого-либо формата, которому ее обучали. Значит, fine-tuning научил не формату; он научил формату, условному на prompts из обучающего набора, и первый prompt, который выглядел иначе, унес формат с собой. То, на чем вы fine-tune, становится тем единственным input distribution, в котором ваша модель хороша, и никто не кладет это в spreadsheet.

Последнее замечание о метрике, прямо указывающее на Главу 29: «правильный источник» оценивает форму и факт вместе, поэтому обе строки retrieval выглядят ужасно, хотя обе модели правильно ответили на факт в этом вопросе. Одно end-to-end число скрывало три вещи — retriever с recall 14/20, 0.5B reader и формат цитирования, — а выбор того, что исправлять, требует разделить их до измерения, а не после.

Теперь столбец, который поставщики заполняют за вас. Fine-tuned модель — не актив, которым вы владеете; это аренда чужой базовой модели, с напечатанной датой окончания. 7 сентября 2026 года раздел fine-tuning на странице pricing OpenAI содержал это уведомление целиком:

OpenAI постепенно закрывает платформу fine-tuning. Платформа больше недоступна новым пользователям, но существующие пользователи платформы fine-tuning смогут создавать training jobs в течение ближайших месяцев. Все fine-tuned модели останутся доступными для inference, пока их базовые модели не будут выведены из эксплуатации.⁷

График расписан по дням: 7 мая 2026 — закрыто для организаций, которые никогда не fine-tune; 2 июля 2026 — закрыто для тех, кто не запускал inference на fine-tuned модели в течение шестидесяти дней; 6 января 2027 — новых jobs больше вообще не будет.⁸ Та же страница планирует отключение самих fine-tuned моделей — ft-gpt-3.5-turbo, ft-gpt-4, ft-gpt-4.1-nano, ft-babbage-002, ft-davinci-002 — на 23 октября 2026 года, каждая с рекомендованной заменяющей базовой моделью, что является вежливым способом сказать: обучайте заново.

Другой frontier-поставщик вообще не продавал вам эту аренду. Индекс документации Anthropic перечисляет 699 страниц, и ни одна не про fine-tuning; разделы кастомизации моделей на странице pricing Bedrock покрывают Amazon Nova, Amazon Titan, Cohere, Meta и OpenAI open-weight models, но не Claude.⁹¹⁰ Если ваша архитектура зависит от fine-tune, одна из трех frontier-семей просто недоступна вам при любом бюджете.

Self-hosting заменяет аренду модели арендой машины, и AWS сама считает эту арифметику на своей странице: одна model unit provisioned throughput для customized model с обязательством на один месяц — «1 model unit × $21.18 × 24 hours × 31 days = $15,757.92» в месяц.¹⁰ Арендовать железо напрямую дешевле, но не бесплатно — $3.99 за GPU-hour on demand для H100, $1.99 preemptible¹¹ — примерно $2,900 в месяц за одну карту, которая должна быть поднята независимо от того, спрашивает ли кто-нибудь что-нибудь. Весь маршрут retrieval при десяти тысячах вопросов в месяц стоит $174.52 за шесть месяцев.

Здесь LoRA получает свое место как бюджетный аргумент, а не технический. На той же модели rank-16 adapter по attention и feed-forward слоям — это 8,798,208 параметров, 1,781 % модели, 17,6 MB в bfloat16, против 0,988 GB базовых weights; его optimiser и gradient state занимают 140,77 MB, тогда как full fine-tuning требует 7,90 GB, фактор 56. Следствие не в более дешевом обучении, а в том, что одна загруженная базовая модель может обслуживать много adapters, и это единственный способ разделить фиксированную стоимость GPU на что-либо. Managed training это отражает: $0.48 за миллион tokens low-rank до 16B против $0.54 full, с минимумом $4.00 за job.¹¹ Этот порог — важная деталь. При 24,389 tokens за три epochs каждое переобучение на этом корпусе выставляет счет на $4.00, а не на $0.04, которые дает арифметика — $104 минимумов за двадцать шесть еженедельных запусков, при девяноста одном центе вычисленной стоимости.

Еще два столбца, которые появляются только в счете.

Data residency стоит примерно десять процентов, и два поставщика сходятся на этой цифре. OpenAI берет «10 % uplift» на data-residency endpoints для моделей, выпущенных 5 марта 2026 года или позже;⁷ Vertex оценивает свои non-global endpoints в $1.65 против $1.50, те же десять процентов.⁶ Сравните это с пятьюдесятью процентами, которые стоит tuned endpoint, и фольклор переворачивается: residency дешева, а fine-tuning — нет; и fine-tuning все равно не является приватным вариантом, потому что корпус доходит до поставщика в любом случае, один раз при обучении вместо одного раза при каждом вызове.

Самая явная цена, когда-либо назначенная вашим данным, находится на той же странице, где одна fine-tuned модель указана дважды: с включенным data sharing inference стоит ровно вдвое меньше — $2.00 против $4.00 input, $8.00 против $16.00 output.⁷ Разрешить поставщику сохранить то, что вы отправили, стоит 50 % скидки, и это говорит, чего оно стоит для него.

Distillation — обучение собственной маленькой модели на ответах большой — обычно предлагают как выход из обоих ограничений. Если посчитать, это не выход, потому что teacher — это система, которую вы пытались заменить: производство двухсот обучающих примеров путем постановки двухсот вопросов маршруту retrieval стоит 200 × $0.002906 = $0.58, сверх $0.73 на обучение по ним. Distillation делают после того, как retrieval pipeline работает, чтобы сделать его дешевле, и он наследует каждый факт, который retriever получил неправильно.

Деньги — видимая половина. Другая приходит как ожидание, с той же причиной, что и счет: модель читает весь prompt, прежде чем сказать слово. Глава 13 измеряла prefill против decode на модели, которую можно было потрогать; здесь то же измерение, один прогон, одна машина, по длине prompt:

Абсолютные числа принадлежат модели 0.5B на шестнадцати CPU threads и ничего не говорят о hosted frontier model. Форма переносится точно: prefill растет с длиной prompt, а стоимость на token ползет вверх, когда начинает проявляться квадратичный член из Главы 9: 4.79 ms на тысяче tokens против 6.04 ms на восьми тысячах, штраф 26 % просто за большую длину.

Следствие для трех маршрутов прямое. Первый маршрут prefills сорок три тысячи tokens на вопрос, и cache hit делает это терпимым — Глава 16 объяснила почему: cache read заменяет работу prefill, значит покупает latency и деньги одной транзакцией. Второй маршрут prefills тысячу и сначала добавляет round trip к индексу. Третий маршрут prefills двадцать восемь и ничего не добавляет, что делает его измеримо самым быстрым из трех в ответе. Он просто отвечает не на то.

Три сбоя, которые выглядят как проблемы модели, но не являются ими, — десять минут здесь экономят месяц потом:

И требование над всем этим: это решение нельзя принять без evaluation set, и поставщик, продающий fine-tune, сам это говорит. Руководство OpenAI начинается с «Only invest in fine-tuning after setting up evals. You need a reliable way to determine whether your fine-tuned model is performing better than a base model» и добавляет, что если пятьдесят хороших примеров ничего не меняют, проблема в задаче или prompt, а не в объеме данных.¹ Двадцать вопросов, как в этой главе, показывают механизм и не могут выбрать поставщика — Глава 4 измерила почему, а что делать, когда двадцать случаев — все, что у вас есть, — повторять их, парно сравнивать и измерять разброс между запусками — это Глава 29.

Четыре столбца, и решает только последний:

Правило, которое из этого следует, достаточно короткое, чтобы держать его в голове: начинайте с prompt; добавляйте retrieval, когда факты движутся; fine-tune только тогда, когда вы измерили, что вам все еще не хватает формы, а не факта, — и прежде чем делать это, считайте ответ, а не prompt.

Неудобная версия для тех, кто пришел уже с решением: в измеренном случае этой главы fine-tuning является самым дешевым маршрутом выше четырех тысяч вопросов в месяц, но по фактам он все равно не может превзойти стратегию отвечать CLAUDE.md на все.

Каждая цена здесь была за token, и каждый маршрут был другим способом расположить tokens. Сейчас это перестанет быть правдой.

Глава 21 покидает текст. Изображение, входящее в модель, — не строка, а сетка patches с числом tokens, которое вы не выбирали; минута речи у одного поставщика тарифицируется по секундам, у другого — по audio token; synthetic speech продается по символам, transcription — по минутам, raw compute — по GPU-second. Вопрос, на который эта глава отвечала одной cost function — что дешевле? — нельзя даже задать, пока единицы не совпадут, и ни один калькулятор в интернете их не нормализует.

Там же снова появляется обучение: image adapter с trigger word и голос, клонированный по образцу. Это поднимает вопрос, с которого начинается следующая глава, и он не риторический: если fine-tuning языковой модели почти всегда неправильная покупка, почему fine-tuning image model почти всегда правильная?

Каждая цена, порог и multiplier в этой главе были прочитаны со страницы самого поставщика 7 сентября 2026 года и цитируются с этой датой, потому что все они изменятся. Измеренные величины — token counts, chunk sizes, retrieval sizes, training loss, scores, latencies и counts из version history — были получены на одной машине в тот же день и воспроизводимы по корпусу, описанному выше.

Локальные эксперименты использовали Qwen/Qwen2.5-0.5B-Instruct с greedy decoding, поэтому они точно воспроизводимы; adapter — двенадцатистрочный класс, напечатанный выше, с rank 8 по q_proj и v_proj. Корпус — отслеживаемая Markdown-документация одного рабочего программного репозитория, исключая два append-only logs; частота ее изменений была посчитана по version history этого репозитория.