Модуль 20. LLM целиком: от токенов до обучения и генерации

Курс «Modern LLMs» · дополнительный итоговый модуль · редакция 2026.10.31

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

Основой станет плотная авторегрессионная MiniLLM с предварительной RMS-нормализацией, RoPE, GQA и SwiGLU. Это определённая конфигурация, а не утверждение о единственном устройстве LLM. После её сборки мы заменим FFN на MoE, затем отдельно разберём SSM и диффузионную генерацию. К завершению модуля у нас будет и компактная итоговая формула, и понимание её границ.

Как читать модуль

Для первого прохода нужны матричное умножение, условная вероятность и смысл градиента. Если вы пока неуверенно владеете этими темами, вернитесь к М3; позиции, внимание и внутренности блока подробнее разобраны в М4–М6. Прочитайте §1–10, затем §13–14 и §17–20. В §11–12 сначала достаточно проследить, что именно изменяет обучение. Выполните У1–У3 и У6 из §18: их предпосылки входят в этот маршрут.

1. Какие три задачи должна описать математика

Начнём с фиксированных весов. На вход модели поступают идентификаторы уже известных токенов. На выходе получается вектор вероятностей следующего токена. Прямой проход — вычисление этого вектора. Он сам по себе не выбирает ответ и не меняет веса.

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

Мы будем считать один пример, без отдельной оси для пакета. Для пакета те же операции выполняются над каждым примером, а потеря объединяет выбранные целевые позиции. Маска внимания отвечает за доступ к контексту; маска потери — за то, какие предсказания участвуют в обучении. Их различие сохранится и в окончательной записи.

Рисунок 1. У прямого прохода есть выход; у обучения и генерации — разные обратные связи. Обучение возвращает градиент к параметрам, генерация возвращает выбранный токен ко входу.

2. Договоримся об обозначениях и границах примера

Обозначим начальный токен как $x_0=\mathrm{BOS}$. Последовательность $x_1,\ldots,x_N$ содержит продолжение и, когда он предусмотрен разметкой, завершающий токен EOS. При предсказании $x_t$ известен префикс $x_0,\ldots,x_{t-1}$ длины $t$. Позиции внутри него нумеруются с нуля. Индекс строки $t-1$ обозначает последнюю известную позицию, а не сам предсказываемый токен.

В этом модуле $h_qd_h=d$, $h_q$ делится на $h_{kv}$, а $d_h$ чётно. Такие ограничения удобны для рассматриваемой конфигурации; они не являются определением любой архитектуры. Смещений линейных слоёв, dropout, QK-нормализации, attention sinks и скользящего окна в базовой записи нет. RoPE используется без растяжения частот. Токены принадлежат одному непрерывному примеру; упаковка независимых документов потребовала бы дополнительной маски границ.

Строка текста превращается в идентификаторы алгоритмом токенизации из М2. Этот дискретный алгоритм не входит в дифференцируемый прямой проход. В численном примере мы зададим идентификаторы непосредственно: так можно проверить всю арифметику без зависимости от корпуса и версии токенизатора.

3. От токенов к начальным представлениям

Входной слой просто выбирает строки таблицы:

$H^{(0)}=E[x_0,\ldots,x_{t-1}].$

Если один идентификатор встретился несколько раз, выбирается одна и та же обучаемая строка. У каждой позиции затем появляется собственная активация, поскольку доступный контекст различается. Таблица $E$ — параметры; выбранная матрица $H^{(0)}$ — результат вычисления на конкретном входе.

Для сквозного примера возьмём словарь $(\mathrm{BOS},A,B,\mathrm{EOS})$ с идентификаторами $(0,1,2,3)$ и последовательность $(0,1,2,3)$. Модель увидит вход $(0,1,2)$ и будет предсказывать цели $(1,2,3)$. Размеры: $V=4$, $d=m=2$, $L=h_q=h_{kv}=1$. Это специально сконструированные данные и веса, а не модель, обученная понимать четыре слова.

$E=\begin{bmatrix}1&0\\0&1\\1&1\\-1&0\end{bmatrix},\qquad H^{(0)}=\begin{bmatrix}1&0\\0&1\\1&1\end{bmatrix}.$

У нас три входные позиции и три предсказания. Цель первой строки — $A$, хотя вход этой строки — BOS. Именно этот сдвиг позволяет учить продолжение, а не копирование текущего идентификатора.

4. RMSNorm: масштаб перед вычислением подслоя

Пусть $h$ — строка длины $d$. Введём её среднеквадратичный масштаб $\rho$ и нормализованную строку:

$\rho(h)=\sqrt{\frac1d\sum_{i=1}^{d}h_i^2+\varepsilon},\qquad N_\gamma(h)=\gamma\odot\frac{h}{\rho(h)}.$

Положительное $\varepsilon$ предотвращает деление на ноль. Мы используем $\varepsilon=10^{-6}$. В отличие от LayerNorm, среднее значение элементов здесь не вычитается. При единичной $\gamma$ и пренебрежимо малом вкладе $\varepsilon$ средний квадрат результата близок к единице. Деление на евклидову длину, напротив, сделало бы единичной длину вектора.

Каждая строка нормируется независимо. Поэтому RMSNorm не смешивает позиции и не нарушает причинность. В блоке будут две разные обучаемые $\gamma$: перед вниманием и перед FFN. Ещё одна стоит после всех блоков. Даже если они инициализированы одинаково, при обучении это разные параметры.

Для всех трёх норм примера начнём с $\gamma=(1,1)$. Тогда вход внимания равен

$X=N_{\gamma_a}(H^{(0)})\approx\begin{bmatrix}1.414212&0\\0&1.414212\\1.000000&1.000000\end{bmatrix}.$

Последняя строка напечатана с округлением: её элементы на самом деле немного меньше единицы из-за $\varepsilon$. Дальше код использует полную точность, а не округлённые числа из таблиц.

5. Проекции и RoPE: содержание встречается с позицией

Из $X$ получаются запросы, ключи и значения. Для головы запросов $j$ и головы ключей/значений $g$:

$Q_j=XW^Q_j,\qquad K_g=XW^K_g,\qquad \mathsf V_g=XW^V_g.$

Каждая из этих матриц имеет форму $t\times d_h$, а каждая соответствующая проекция — $d\times d_h$. В этой записи $V$ по-прежнему обозначает размер словаря; $\mathsf V_g$ обозначает активации значений. Запрос и ключ будут сравниваться, а значения — складываться с найденными весами.

RoPE вращает координаты запросов и ключей отдельно в каждой позиции. Для конвенции rotate_half координата $i$ спаривается с $i+d_h/2$, где $i=0,\ldots,d_h/2-1$. При частоте $\omega_i=10000^{-2i/d_h}$ и позиции $p$:

$\begin{aligned}a'&=a\cos(p\omega_i)-b\sin(p\omega_i),\\b'&=a\sin(p\omega_i)+b\cos(p\omega_i).\end{aligned}$

Запишем этот оператор как $\mathcal R_p$. Он применяется к строкам $Q_j$ и $K_g$, давая $\widetilde Q_j$ и $\widetilde K_g$; значения $\mathsf V_g$ в данной архитектуре не вращаются. Вращение не добавляет обучаемых параметров. При сравнении двух вращённых векторов в скалярном произведении возникает разность позиций — поэтому внимание получает информацию об относительном расположении токенов. Порядок спаривания координат является частью конфигурации, а не свободной косметической заменой.

В примере $W^Q=W^K=0.5I_2$, $W^V=\operatorname{diag}(0.5,1)$. Есть единственная пара координат и $\omega_0=1$. Для позиций 0, 1 и 2 углы равны соответственно 0, 1 и 2 радианам:

$\widetilde Q=\widetilde K\approx\begin{bmatrix}0.707106&0\\-0.595009&0.382051\\-0.662722&0.246575\end{bmatrix},\quad \mathsf V\approx\begin{bmatrix}0.707106&0\\0&1.414212\\0.500000&1.000000\end{bmatrix}.$

Равенство запросов и ключей здесь вызвано выбранными весами. Общая формула его не предполагает.

6. Причинное внимание и совместное использование K/V

При GQA несколько голов запросов используют одну голову ключей и значений. При нумерации голов с нуля определим $g(j)=\lfloor j/(h_q/h_{kv})\rfloor$. Головы остаются различными, поскольку их запросы вычислены разными $W^Q_j$. Совместное использование K/V сокращает соответствующие проекции и кэш; оно не усредняет запросы.

Для строки $i$ разрешим ключи только из позиций $r\le i$:

$M_{ir}=\begin{cases}0,&r\le i,\\-\infty,&r\gt i.\end{cases}$

Теперь голова внимания определена полностью:

$S_j=\frac{\widetilde Q_j\widetilde K_{g(j)}^\top}{\sqrt{d_h}}+M,\qquad A_j=\operatorname{softmax}_{\rm row}(S_j),\qquad O_j=A_j\mathsf V_{g(j)}.$

Softmax превращает разрешённые оценки строки в положительные веса с суммой 1; запрещённые получают ноль. Первая позиция может смотреть на себя, поэтому полностью закрытых строк здесь нет. Выход головы имеет форму $t\times d_h$. Склеив головы по координатам и применив выходную проекцию $W^O\in\mathbb R^{d\times d}$, получим оператор $\mathcal A(X)=\operatorname{Concat}(O_0,\ldots,O_{h_q-1})W^O$.

В нашем примере веса последней строки примерно равны $(0.201972,0.397396,0.400632)$. Например, первая из её трёх оценок до softmax — $(-0.662722\cdot0.707106+0.246575\cdot0)/\sqrt2\approx-0.331361$. Здесь виден весь путь: скалярное произведение, масштаб, маска, нормировка, взвешенная сумма значений.

Рисунок 2. Матрица $A$ сквозного примера. Нули справа от диагонали заданы маской, остальные числа вычислены из запросов и ключей.

Возьмём $W^O=0.25I_2$. После первой остаточной связи получаем

$Z=H^{(0)}+\mathcal A(X)\approx\begin{bmatrix}1.176777&0\\0.060590&1.232372\\1.085783&1.240658\end{bmatrix}.$

Добавляется результат внимания, а не нормализованный вход $X$. По остаточной ветви проходит исходное представление $H^{(0)}$; эта деталь будет существенна и в обратном проходе.

7. FFN и полный блок: где заканчивается один слой

Внимание переносило информацию между позициями. FFN преобразует каждую строку по отдельности, уже после этого обмена. Для входа $Y$ введём

$\mathcal F(Y)=\big[\operatorname{SiLU}(YW^{\rm gate})\odot(YW^{\rm up})\big]W^{\rm down},\qquad \operatorname{SiLU}(a)=a\sigma(a),\quad \sigma(a)=\frac1{1+e^{-a}}.$

Матрицы $W^{\rm gate}$ и $W^{\rm up}$ имеют форму $d\times m$, а $W^{\rm down}$ — $m\times d$. Две ветви переводят представление в пространство ширины $m$; нелинейная ветвь регулирует поэлементное произведение, после чего выход возвращается к ширине $d$. Это SwiGLU из М6.

Для примера зададим

$W^{\rm gate}=\begin{bmatrix}0.5&-0.25\\0.25&0.5\end{bmatrix},\quad W^{\rm up}=\begin{bmatrix}1&0.5\\-0.5&1\end{bmatrix},\quad W^{\rm down}=0.25I_2.$

Нормализация $Y=N_{\gamma_f}(Z)$ даёт первую строку примерно $(1.414213,0)$. Её gate-ветвь равна $(0.707106,-0.353553)$, up-ветвь — $(1.414213,0.707106)$, выход FFN — $(0.167440,-0.025783)$. Отрицательная компонента допустима: SiLU не обнуляет все отрицательные входы.

Полный блок $\mathcal B_\ell$ теперь можно записать без пропусков:

$\boxed{\begin{aligned}Z^{(\ell)}&=H^{(\ell-1)}+\mathcal A_\ell\big(N_{\gamma_{a,\ell}}(H^{(\ell-1)})\big),\\H^{(\ell)}&=Z^{(\ell)}+\mathcal F_\ell\big(N_{\gamma_{f,\ell}}(Z^{(\ell)})\big).\end{aligned}}$

У каждого слоя свои проекции и свои множители нормализации. В примере слой один:

$H^{(1)}\approx\begin{bmatrix}1.344217&-0.025783\\0.023804&1.398300\\1.135097&1.306390\end{bmatrix}.$

Рисунок 3. Норма находится на входе каждой преобразующей ветви. На линиях обхода сохраняется представление до соответствующего подслоя.

8. Стек блоков, выход и состав параметров

Последовательное применение блоков обозначим композицией: правый оператор действует первым. После последнего блока ещё раз нормализуем представление и получим логиты:

$H^{(L)}=(\mathcal B_L\circ\cdots\circ\mathcal B_1)(H^{(0)}),\qquad R=N_{\gamma_o}(H^{(L)}),\qquad \Lambda=RU.$

Логиты $\Lambda$ — произвольные вещественные оценки, не вероятности. Выходной softmax применяется к $V$ столбцам каждой строки. При связанных эмбеддингах $U=E^\top$: это одна таблица с двумя ролями, а не две копии, которые случайно равны. В базовом численном примере $U$ независима от $E$.

Число параметров помогает проверить, что ни одна обучаемая часть не исчезла из формулы. Для одинаковых плотных блоков выбранной конфигурации:

$P=n_E Vd+L\big(2d^2+2d h_{kv}d_h+3dm+2d\big)+d,\qquad n_E=\begin{cases}1,&U=E^\top,\\2,&U\text{ независима.}\end{cases}$

Здесь $2d^2$ — запросы и выход внимания, $2dh_{kv}d_h$ — ключи и значения, $3dm$ — три матрицы FFN, $2d$ — две нормы блока, последний $d$ — конечная норма. Для наших размеров получаем $16+16+12+4+2=50$. При связывании таблиц осталось бы 42. Для $d=4,m=3,h_q=2,h_{kv}=1,V=4,L=1$ независимые таблицы дают 128 параметров; при $h_{kv}=2$ было бы 144.

Таким образом, $\theta$ содержит таблицы, линейные проекции и множители нормализации. Идентификаторы токенов, причинная маска и фиксированные частоты RoPE не обучаются. Активации, градиенты, кэш и моменты оптимизатора занимают память, но не прибавляются к числу параметров модели. Это различие связывает формулу с расчётами памяти из М9–М10.

9. Вероятности: завершаем сквозной прямой проход

Используем выходную матрицу

$U=\begin{bmatrix}0&0.5&-0.5&0.25\\0&-0.25&0.5&-0.5\end{bmatrix}.$

После конечной RMSNorm строки $R$ примерно равны $(1.413953,-0.027120)$, $(0.024071,1.414008)$ и $(0.927561,1.067535)$. Умножение на $U$ даёт следующие результаты. В каждой четвёрке порядок столбцов один: BOS, A, B, EOS.

Третья цель имеет невысокую вероятность. Это не ошибка вычисления: выбранные вручную веса не обязаны хорошо предсказывать нашу последовательность. Напротив, теперь есть понятная ошибка, на которой можно проследить обучение.

Softmax вычисляем устойчиво: из всех логитов строки вычитаем их максимум. Прибавление одной константы ко всем логитам не меняет распределение, но прямое экспоненцирование больших положительных чисел может переполниться. Во всей арифметике модуля используются натуральные логарифмы; потери измеряются в натах.

10. От условного распределения к вероятности текста и потере

Последняя строка прямого прохода по префиксу задаёт $p_\theta(x_t\mid x_0,\ldots,x_{t-1})$. Вероятность определённой последовательности при фиксированном BOS раскладывается так:

$p_\theta(x_1,\ldots,x_N\mid x_0)=\prod_{t=1}^{N}p_\theta(x_t\mid x_0,\ldots,x_{t-1}).$

Если требуется вероятность завершённого ответа, в последовательность включают EOS. Если EOS не включён, произведение описывает вероятность данного префикса. При обучении весь правильный текст уже известен, поэтому можно вычислить все условные распределения одним причинно замаскированным проходом. Это teacher forcing: в контекст каждой позиции попадает правильное прошлое, а не ранее сгенерированное продолжение. Параллельное вычисление строк не открывает доступ к будущему.

Пусть $b_t\in\{0,1\}$ выбирает целевые позиции, а $n=\sum_t b_t\gt0$. Средняя кросс-энтропия равна

$\mathcal L(\theta)=-\frac1n\sum_{t=1}^{N}b_t\log p_\theta(x_t\mid x_{\lt t}).$

Запись $x_{\lt t}$ включает BOS и все предшествующие токены. Для пакета сумма и $n$ охватывают все выбранные цели пакета. Это конкретная нормировка по токенам; усреднение сначала по ответам, а затем по примерам задаёт другую весовую схему.

В примере все три $b_t=1$. Отдельные потери равны $0.889986$, $0.742606$ и $1.695530$, среднее — 1.109373924. Можно получить его и напрямую из логитов, используя $\log\sum_v e^{\Lambda_{t-1,v}}-\Lambda_{t-1,x_t}$. Если выбрать только EOS, потеря станет $1.695530$, а не третью этого значения. Пустая маска не задаёт среднее; код сообщает об ошибке.

11. Обратный проход: как ошибка достигает каждой матрицы

Компактная запись $\nabla_\theta\mathcal L$ полезна только тогда, когда понятно, через какие операции проходит производная. Для начала возьмём строку логитов $\lambda$ и правильный идентификатор $y$. После softmax и кросс-энтропии:

$\frac{\partial\mathcal L}{\partial\lambda_v}=\frac{b}{n}\big(p_v-\mathbf1[v=y]\big).$

Для последней строки нашего примера градиент равен примерно $(0.082722,0.100724,0.088719,-0.272166)$. Его сумма равна нулю: прибавление общей константы к логитам не влияет на потерю. Отрицательная производная правильного логита означает, что его увеличение при прочих равных уменьшает ошибку.

Обозначим входящий градиент через $G$. Для линейного слоя $Y=XW$ правило цепочки даёт $G_X=G_YW^\top$ и $G_W=X^\top G_Y$. Для остаточного сложения $Z=H+F(H)$ оно даёт $G_H=G_Z+J_F(H)^\top G_Z$, если строки развёрнуты в вектор. Единичная ветвь сохраняет прямой путь градиента, но не отменяет производную преобразования.

В SwiGLU положим $a=YW^{\rm gate}$, $u=YW^{\rm up}$ и $c=\operatorname{SiLU}(a)\odot u$. Тогда

$G_a=G_c\odot u\odot\big[\sigma(a)+a\sigma(a)(1-\sigma(a))\big],\qquad G_u=G_c\odot\operatorname{SiLU}(a).$

Далее обе ветви проходят через линейные проекции и складываются на входе $Y$. Для нормы одной строки удобно сначала умножить входящий градиент на обучаемый множитель: $v=G_{N(h)}\odot\gamma$. Получаем

$G_h=\frac{v}{\rho}-\frac{h\,(v\cdot h)}{d\rho^3},\qquad G_\gamma=G_{N(h)}\odot\frac{h}{\rho}.$

Градиенты $\gamma$ суммируются по всем строкам. Здесь используется та же $\rho$ с $\varepsilon$, что и в прямом проходе; убирать $\varepsilon$ при дифференцировании нельзя.

Для одной головы внимание разбивается на знакомые операции. Из $O=A\mathsf V$ следуют $G_A=G_O\mathsf V^\top$ и $G_{\mathsf V}=A^\top G_O$. Если $a$ — строка softmax, то её обратный проход записывается без полной матрицы Якоби:

$G_s=a\odot\big(G_a-(G_a\cdot a)\mathbf1\big).$

На запрещённых маской позициях производная равна нулю. Для разрешённых оценок $S=\widetilde Q\widetilde K^\top/\sqrt{d_h}+M$:

$G_{\widetilde Q}=G_S\widetilde K/\sqrt{d_h},\qquad G_{\widetilde K}=G_S^\top\widetilde Q/\sqrt{d_h}.$

RoPE возвращает градиент обратным вращением. В GQA градиенты общего K/V от всех использующих его голов складываются. При выборе строк $E$ градиенты накапливаются в соответствующих строках таблицы; повторный токен добавляет ещё одно слагаемое. При $U=E^\top$ к ним прибавляется градиент выходной проекции. Так путь замыкается на всех параметрах, перечисленных в §8.

Ноутбук проверяет этот путь двумя способами. PyTorch строит обратный проход автоматически, а NumPy оценивает каждую из 50 производных независимо по центральной разности $(\mathcal L(\theta_i+h)-\mathcal L(\theta_i-h))/(2h)$ при $h=10^{-5}$. Отдельная проверка связывает эмбеддинги и проверяет все 42 параметра. Это проверка конкретной гладкой конфигурации в float64, а не доказательство для любой модификации архитектуры.

12. Шаг AdamW: градиент превращается в новые веса

Чтобы получить следующую модель, одного градиента недостаточно: нужно правило обновления и состояние оптимизатора. Пусть $g_s$ — градиент на шаге обучения $s$. Если задан порог $c$, сначала выполним глобальное ограничение нормы:

$\widetilde g_s=g_s\min\left(1,\frac{c}{\lVert g_s\rVert_2}\right).$

При нулевом градиенте множитель считается равным 1. Норма охватывает все обучаемые скаляры. Это не обрезание каждого элемента независимо. Затем AdamW обновляет два накопителя:

$m_s=\beta_1m_{s-1}+(1-\beta_1)\widetilde g_s,\qquad v_s=\beta_2v_{s-1}+(1-\beta_2)\widetilde g_s^2,$ $\widehat m_s=\frac{m_s}{1-\beta_1^s},\quad \widehat v_s=\frac{v_s}{1-\beta_2^s},\quad \theta_s=(1-\eta_s\lambda)\theta_{s-1}-\eta_s\frac{\widehat m_s}{\sqrt{\widehat v_s}+\varepsilon_{\rm opt}}.$

Квадрат, корень и деление в этих формулах поэлементные. $\eta_s$ — скорость обучения; $\lambda$ — коэффициент weight decay, который может различаться по группам параметров. В нашем опыте матрицы получают $\lambda=0.1$, множители норм — $\lambda=0$. Это выбранное правило эксперимента, не универсальное требование AdamW. Оптимизаторное $\varepsilon_{\rm opt}=10^{-8}$ отлично от $\varepsilon$ в RMSNorm.

Начнём с нулевых моментов, $\beta_1=0.9$, $\beta_2=0.95$, $\eta_1=0.01$, $c=1$. Норма градиента равна 0.587186334, поэтому ограничение не срабатывает. После коррекции смещения на первом шаге $\widehat m_1=g_1$ и $\widehat v_1=g_1^2$. Потеря на той же последовательности снижается с 1.109373924 до 1.084831548.

Это наблюдение для одного конкретного шага. Оно не доказывает ни монотонного уменьшения потери на каждом шаге, ни улучшения на новых данных. Дальнейшие шаги используют историю моментов: нельзя каждый раз подставлять формулу первого шага. Ноутбук сравнивает наше обновление с torch.optim.AdamW, а затем отдельно выполняет короткое обучение с сохраняющимся состоянием оптимизатора.

Рисунок 4. Изменяется одно и то же распределение из §9. Столбцы показывают вероятности правильных целей; линия случайного равномерного распределения равна 0.25.

13. Генерация: распределение не равно выбранному тексту

Во время инференса фиксируем $\theta$ и начинаем с известного префикса. Можно выбрать токен с максимальной вероятностью, а можно сэмплировать. Температура $\tau\gt0$ и множество разрешённых кандидатов $K$ задают распределение декодера

$q(v\mid x_{\lt t})=\frac{\mathbf1[v\in K]\exp(\lambda_v/\tau)}{\sum_{u\in K}\exp(\lambda_u/\tau)}.$

При $\tau=1$ и полном словаре $q=p_\theta$. При top-k множество $K$ содержит $k$ наибольших логитов, после чего оставшиеся вероятности перенормируются. Выбор токена, его добавление и условие остановки относятся к алгоритму генерации. Argmax описывается отдельно: подставлять нулевую температуру в формулу нельзя.

Для последней строки примера top-2 оставляет A и B. При $\tau=0.5$ получаем $q=(0,0.563116,0.436884,0)$. EOS в этот шаг исключён, хотя базовая модель назначала ему вероятность 0.183502. Поэтому вероятности сгенерированных текстов при таком декодере образуются из $q$, а не из исходного $p_\theta$.

После выбора токена новый префикс проходит через ту же модель. Цикл завершается при EOS или при достижении заданного предела длины. Без предела наличие EOS в словаре ещё не гарантирует остановку за конечное число шагов для произвольных весов и правил выбора. Воспроизводимый опыт фиксирует веса, префикс, параметры декодирования и seed генератора случайных чисел.

14. KV-cache: то же вычисление с сохранённым прошлым

В причинной модели добавление нового токена не меняет активации старых позиций. Это следует по слоям: норма и FFN действуют отдельно по строкам, а внимание старой строки не получает новых разрешённых ключей. Поэтому ключи и значения уже обработанного префикса можно сохранить.

На следующем шаге каждый слой вычисляет запрос, ключ и значение только для новых позиций, добавляет новые K/V к своему кэшу и обращается ко всем разрешённым ключам. В нашей конвенции сохраняются уже повёрнутые ключи и обычные значения. Новый запрос должен использовать абсолютную позицию в префиксе: после трёх токенов это 3, а не 0.

Для полного внимания объём элементов кэша на один пример после $t$ токенов равен $2Lth_{kv}d_h$. В однослойном примере после трёх входов это 12 скаляров; при float32 — 48 байт без служебных накладных расходов. Веса не меняются и не входят в эту сумму. GQA экономит K/V по числу $h_{kv}$, хотя запросов остаётся $h_q$.

Кэш допустим для того же префикса, тех же весов и тех же правил позиций. После обновления весов его нужно пересчитать. Ограничение окна, квантизация кэша и смена позиционной схемы требуют отдельных условий эквивалентности. Наши проверки сравнивают полный проход, по одному токену и по нескольку новых токенов; небольшие расхождения float32 допустимы, изменение математического результата — нет.

Рисунок 5. Кэш меняет организацию вычисления. Он не является дополнительной обучаемой памятью модели.

15. MoE: заменяем конкретный оператор, сохраняя остальную конструкцию

В М7 мы заменяли плотный FFN набором экспертов. Теперь можно точно указать место замены: в §7 вместо $\mathcal F_\ell$ подставляется $\mathcal F_{\rm MoE,\ell}$. Внимание, остаточные связи, выходная проекция и авторегрессионное разложение остаются на месте, если остальные настройки сохранены.

Опишем вариант MiniLLM с sigmoid-маршрутизацией без ограничения ёмкости экспертов. Пусть маршрутизируемых экспертов $E_r$, а матрица роутера $W^r\in\mathbb R^{d\times E_r}$. Для одной нормализованной строки $y$ роутер вычисляет $r=yW^r$ и $a_e=\sigma(r_e)$. Балансировочная поправка $b_e$ влияет на выбор множества экспертов $S(y)=\operatorname{TopK}_e(a_e+b_e)$, но веса смеси считаются из исходных $a_e$:

$w_e(y)=\frac{a_e}{\varepsilon_r+\sum_{j\in S(y)}a_j},\quad e\in S(y),\qquad \mathcal F_{\rm MoE}(y)=\sum_{e\in S(y)}w_e(y)\mathcal F_e(y)+\sum_{e\in\mathcal S_{\rm shared}}\mathcal F_e(y).$

В MiniLLM стабилизатор знаменателя равен $\varepsilon_r=10^{-9}$. Без него веса выбранных экспертов в точности суммировались бы в 1; с ним сумма чуть меньше. При обычных значениях это малая численная поправка, но при почти нулевых sigmoid-оценках её уже нельзя игнорировать. Каждый эксперт — свой SwiGLU. Общие эксперты из $\mathcal S_{\rm shared}$ включены всегда и в данном варианте складываются без нормировки вместе с маршрутизируемой частью. Другие реализации могут использовать иное масштабирование; оно должно быть явно добавлено в формулу.

Возьмём три логита $(0,1,-1)$, поправки $(0,-0.5,0.5)$ и top-2. Получаются оценки sigmoid $(0.5,0.731059,0.268941)$, а для выбора — $(0.5,0.231059,0.768941)$. Выбраны эксперты 2 и 0 с нормированными весами примерно $(0.349755,0.650245)$. Прибавлять поправку ещё раз к этим весам было бы другой моделью.

При фиксированном наборе выбранных экспертов градиент проходит через их выходы и нормированные веса. Сам top-k дискретен: на границе смены набора обычной гладкой производной нет. Поправки балансировки MiniLLM обновляет отдельным правилом, а не AdamW по кросс-энтропии. Поэтому они относятся к состоянию маршрутизации, а не к $\theta$ обучаемых градиентом матриц. Ограничение ёмкости и отбрасывание токенов здесь исключены: они добавили бы зависимость от состава и порядка назначений в пакете.

16. Что меняет постобучение и что остаётся за пределами модели

SFT может оставить весь прямой проход прежним, но выбрать маской $b_t$ только целевые токены ответа. Токены инструкции при этом по-прежнему доступны вниманию: исключение из потери не исключает их из контекста. При LoRA изменяется параметризация некоторых матриц: для $W_0\in\mathbb R^{d_{\rm in}\times d_{\rm out}}$ можно записать $W=W_0+(\alpha/r)AB$, где $A\in\mathbb R^{d_{\rm in}\times r}$, $B\in\mathbb R^{r\times d_{\rm out}}$, $r\gt0$ — ранг адаптера, а $\alpha$ — заданный масштаб. Замороженная часть $W_0$ участвует в вычислении, но не обновляется оптимизатором; обучаются матрицы адаптера.

При обучении по предпочтениям меняется сама цель. Для DPO введём $\ell_\theta(y\mid c)=\sum_i\log p_\theta(y_i\mid c,y_{\lt i})$, то есть сумму логарифмов вероятностей токенов ответа при условии промпта $c$. Пусть $y^+$ предпочтительнее $y^-$, а $\pi_{\rm ref}$ — фиксированная опорная модель. Обозначим такую же сумму токенных логарифмов для неё через $\ell_{\rm ref}$. Тогда для одной пары:

$\mathcal L_{\rm DPO}=-\log\sigma\!\left(\beta\left[\ell_\theta(y^+\mid c)-\ell_\theta(y^-\mid c)-\ell_{\rm ref}(y^+\mid c)+\ell_{\rm ref}(y^-\mid c)\right]\right).$

Коэффициент $\beta\gt0$ регулирует масштаб сравнения. Превращение суммы токенных логарифмов в среднее по длине изменило бы эту цель. Подробный вывод и ограничения разобраны в М14; здесь важна связь: одно и то же $p_\theta$ можно обучать разными способами.

В мультимодальной модели входной оператор может вставлять проекции изображений или аудио, а не только строки $E$. Поиск добавляет найденные материалы к контексту; агентная обвязка вызывает инструменты и формирует следующий запрос. Эти механизмы не возникают из одного умножения на $U$. Формула ядра объясняет вычисление распределения, но не является доказательством истинности ответа, качества поиска или надёжности всей системы. Именно поэтому курс завершается не только архитектурой, но и оценкой в М19.

19. Где итоговая конструкция меняется: SSM и диффузия

SSM: другое представление прошлого

Внимание сохраняет отдельные K/V прошлых позиций и читает их в зависимости от нового запроса. Модель пространства состояний, SSM, переносит между позициями состояние фиксированной для выбранной архитектуры формы. В дискретном виде ядро такого оператора можно записать так:

$s_p=\overline A_p s_{p-1}+\overline B_p u_p,\qquad y_p=C_p s_p+D u_p.$

В этой локальной записи используем векторы-столбцы: $u_p\in\mathbb R^{d_u}$ — вход в позиции $p$, $s_p\in\mathbb R^n$ — состояние, $y_p\in\mathbb R^{d_y}$ — выход. Тогда $\overline A_p\in\mathbb R^{n\times n}$, $\overline B_p\in\mathbb R^{n\times d_u}$, $C_p\in\mathbb R^{d_y\times n}$ и $D\in\mathbb R^{d_y\times d_u}$. В селективных моделях некоторые коэффициенты зависят от текущего входа. Черта означает уже дискретизированные коэффициенты; переход от непрерывной системы разобран в М8.

Для прозрачного частного случая положим $\overline A=0.5$, $\overline B=C=1$, $D=0$, $s_{-1}=0$. На входах $(1,0,-1)$ получаем состояния и выходы $(1,0.5,-0.75)$. Старые входы влияют на ответ через состояние, а не через отдельные адресуемые записи K/V. Число скаляров этого состояния не растёт с длиной префикса; это не означает сохранения любой информации о прошлом без потерь.

В формуле стека теперь нужен SSM-блок вместо соответствующего attention-блока. Нельзя объявить, что вся Mamba получается буквальной заменой одного произведения $QK^\top$: конкретный блок может включать проекции, свёртку и гейтирование, а отдельного FFN может не быть. Гибридная сеть чередует разные блоки. Но если модель по-прежнему причинно предсказывает следующий токен, выходной softmax, произведение условных вероятностей и токенная кросс-энтропия сохраняют свой смысл. Основная перемена — оператор обработки контекста и переносимое состояние. Mamba даёт конкретную реализацию этой идеи.

Диффузия: другой путь от случайности к тексту

У диффузионной модели изменяется уже организация генерации. Чтобы не смешивать шаги с позициями токенов, обозначим целую последовательность на уровне шума $s$ через $z^{(s)}$. Чистая последовательность — $z^{(0)}$. Начальная $z^{(S)}$ берётся из заданного распределения шума; в маскирующем варианте это может быть строка из MASK. Деноизер получает текущую последовательность и информацию об уровне шума, а не только неизменяемый левый префикс.

Если $K_{\theta,s}(z^{(s-1)}\mid z^{(s)},c)$ обозначает нормированное обратное переходное распределение при условии промпта $c$, то для фиксированной длины:

$\boxed{p_\theta(z^{(0)}\mid c)=\sum_{z^{(1)},\ldots,z^{(S)}}p_S(z^{(S)}\mid c)\prod_{s=1}^{S}K_{\theta,s}(z^{(s-1)}\mid z^{(s)},c).}$

Произведение описывает одну траекторию уточнения. Сумма учитывает все скрытые промежуточные последовательности: одной и той же чистой строке могут предшествовать разные пути. Для непрерывного шума соответствующие суммы заменяются интегралами. Если длина тоже генерируется, её распределение нужно добавить отдельно.

Выход деноизера часто задаёт вероятности чистых токенов, а переход $K$ дополнительно строится с учётом схемы зашумления и расписания. Поэтому $K$ нельзя автоматически приравнять к softmax одного токена. Маска внимания также может быть двунаправленной: позиции читают доступное состояние всей зашумлённой последовательности. Простое снятие причинной маски при обучении копировать открытые правильные токены дало бы утечку ответа, а не корректную диффузионную задачу. В М12 обучение восстанавливает скрытые токены из испорченного входа; в общем случае цель задаётся прямым процессом зашумления и выбранным выводом обратной модели. D3PM формализует такие дискретные процессы.

Проверим смысл суммы на крошечной заданной вручную обратной цепи, не выдавая её за обученный деноизер. Есть две бинарные позиции и четыре строки: 00, 01, 10, 11. Из двух MASK первый переход выдаёт распределение $r=(0.18,0.42,0.12,0.28)$. На втором переходе каждый бит независимо сохраняется с вероятностью 0.8 и меняется с вероятностью 0.2. Если две строки отличаются в $h$ позициях, переход между ними равен $0.8^{2-h}0.2^h$. Умножение $rK$ даёт $(0.2128,0.3472,0.1672,0.2728)$. Например, вероятность 00 равна $0.18\cdot0.64+0.42\cdot0.16+0.12\cdot0.16+0.28\cdot0.04=0.2128$ — это сумма четырёх путей, а не предсказание первого, затем второго бита.

Рисунок 6. У SSM может сохраниться авторегрессионная постановка. У диффузии шаг уточнения относится к целой последовательности; повторное вычисление её представлений обычно не допускает обычного append-only KV-cache.

Любое нормированное совместное распределение можно формально разложить по цепному правилу на условные вероятности токенов. Однако это тождество не делает диффузионный алгоритм авторегрессионным: вычисление таких условных вероятностей может потребовать суммирования по скрытым траекториям. Архитектура деноизера, вероятностная модель и алгоритм выборки — связанные, но разные уровни описания.

20. Итоговая запись и как её читать

Вернёмся к выбранной плотной MiniLLM. Обозначим остаточное добавление через $\mathcal T_G(H)=H+G(H)$. Тогда $\mathcal B_\ell=\mathcal T_{\mathcal F_\ell\circ N_{\gamma_{f,\ell}}}\circ\mathcal T_{\mathcal A_\ell\circ N_{\gamma_{a,\ell}}}$. Все внутренние операции $\mathcal A$ и $\mathcal F$ уже раскрыты в §5–7. Одна условная вероятность записывается так:

$\boxed{p_\theta(x_t=v\mid x_{\lt t})=\left[\operatorname{softmax}\!\left(\left[N_{\gamma_o}\!\left((\mathcal B_L\circ\cdots\circ\mathcal B_1)(E[x_{\lt t}])\right)\right]_{t-1,:}U\right)\right]_v.}$

Читаем изнутри наружу: выбираем эмбеддинги префикса; проводим их через последовательность полностью определённых блоков; нормализуем; берём последнюю строку; умножаем на выходную матрицу; нормируем логиты; выбираем компоненту нужного токена. В вычислении всех обучающих позиций последнюю строку не выделяют: выходная проекция применяется ко всей матрице.

Для вероятности последовательности умножаем эти условные вероятности. Для обучения берём выбранную потерю, дифференцируем по $\theta$ и применяем обновление вместе с состоянием оптимизатора. Для генерации строим $q$ из последней строки и повторяем шаг после выбора токена. Таким образом, окончательная запись всей процедуры состоит из согласованных частей:

$\boxed{\begin{aligned}p_\theta(x_{1:N}\mid x_0)&=\prod_{t=1}^{N}p_\theta(x_t\mid x_{\lt t}),\\\mathcal L(\theta)&=-\frac{1}{\sum_t b_t}\sum_t b_t\log p_\theta(x_t\mid x_{\lt t}),\\(\theta_s,m_s,v_s)&=\operatorname{AdamW}_s\!\left(\theta_{s-1},m_{s-1},v_{s-1},\nabla_\theta\mathcal L(\theta_{s-1})\right),\\x_t&\sim q_\theta(\,\cdot\mid x_{\lt t})\quad\text{при фиксированных весах.}\end{aligned}}$

В оператор AdamW здесь входят ограничение нормы, расписание скорости обучения и группы weight decay, определённые в §12. Последняя строка описывает сэмплирование; при жадном декодировании вместо неё используется argmax. Эти строки не исполняются одновременно: обучение меняет веса, генерация использует выбранный чекпойнт.

У формулы теперь есть проверяемая область действия. MoE заменяет $\mathcal F$ и добавляет маршрутизацию. SSM меняет блок и форму состояния, сохраняя авторегрессионную цель, если она выбрана. Диффузия использует другую траекторию генерации и другое разложение через скрытые состояния. Масштаб модели, данные и обучение определяют то, чему научились параметры; архитектурная запись сама по себе не сообщает уровень её способностей. Зато она позволяет точно указать, какое вычисление выполняет модель, что в нём обучается и где начинается следующий алгоритм.

Источники и продолжение работы

Подробные выводы отдельных механизмов остаются в М3–М9, М12–М14. Первичные описания: Attention Is All You Need, RMSNorm, RoFormer, GQA, AdamW, DPO. Формулы этого модуля фиксируют конкретную конфигурацию учебной MiniLLM; численные матрицы созданы специально для сквозного примера.

Завершите чтение самопроверкой: на первом проходе выполните 13 вопросов без пометки, а к 20.11.1 и 20.15.1 вернитесь после подробного разбора §11 и §15 соответственно. Затем можно вернуться к практикуму MiniLLM и сопоставить его config.json с членами формулы. Теперь изменение числа голов, связывания эмбеддингов или вида FFN должно означать для вас определённую замену размеров, операций и параметров, которую можно проверить вычислением.