Reading the Math in AI Papers · Часть 2 из 2

Как читать уравнения архитектур: RoPE, MLA, MoE и LoRA

Viacheslav Dubrov

2026-11-11 · Обновлено 2026-11-11 · 15 мин · Инженерия моделей

Автоматический перевод

Эта статья была автоматически переведена с оригинальной английской версии.

Эта статья объясняет, что меняют шесть методов архитектуры моделей: откуда аттеншн получает информацию о позиции, что хранит в памяти, какие токены или экспертов использует и какие веса обновляет файн-тюнинг. Она предназначена для инженеров, которые знают общую структуру Transformer, но хотят понять RoPE, MLA, разреженный аттеншн, Gated DeltaNet, MoE и LoRA без разбора всех выводов в каждой статье. Диаграммы сравнивают механизмы; уравнения объясняют главное изменение.

Токен поступает в модель как числовой вектор, который называется эмбеддингом. Каждый слой обновляет это представление. В аттеншне три умножения на обученные матрицы, или проекции, превращают входные векторы токенов в запросы ( $Q$ ), ключи ( $K$ ) и значения ( $V$ ). Обозначения $W_Q$ , $W_K$ и $W_V$ на диаграмме называют эти обученные матрицы.

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

\begin{aligned} &\operatorname{Attention}(Q,K,V)\\ &\qquad=\operatorname{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V. \end{aligned}

Читайте операции по порядку: $QK^\top$ сравнивает каждый запрос с каждым ключом; $\top$ транспонирует матрицу ключей, чтобы расположить векторы для умножения. Разделите на квадратный корень из их длины $d_k$ , затем примените softmax к каждой строке, чтобы получить веса. Умножение на $V$ усредняет значения с этими весами. Результат — обновлённый вектор каждого токена, который передаётся дальше по слою. В каузальной языковой модели аттеншн исключает будущие токены перед softmax. В части 1 это вычисление разобрано на маленьких матрицах.

Первые четыре раздела меняют это вычисление или его память. MoE меняет сеть прямого распространения, а LoRA — способ обучения весов. Разделы можно читать независимо; диаграмма MLA использует механизм позиции из раздела RoPE.

RoPE: позиция как поворот

Скалярное произведение запроса и ключа сравнивает векторы содержания. Само по себе оно не говорит, стоят ли два токена рядом или между ними сто позиций. Исходный Transformer добавляет вектор позиции к эмбеддингу каждого токена перед первым слоем аттеншна. Затем информация о позиции влияет на запросы, ключи и значения, вычисленные из этих входов. Она не поворачивает их. См. Attention Is All You Need, §3.5.

RoPE вводит позицию в само сравнение запроса и ключа. Сначала вычислите запросы и ключи с помощью обычных обученных проекций. Затем поверните пары их координат на углы, определяемые позицией каждого токена. Вычислите оценки аттеншна по повёрнутым векторам. RoPE не поворачивает значения.

Два блока ниже показывают, где вводится позиция. Вычисление взвешенных значений в обоих случаях по-прежнему идёт после вычисления оценок.

$Исходный Transformer добавляет позицию ко входу перед получением запросов, ключей и значений. RoPE поворачивает спроецированные запросы и ключи перед их скалярным произведением, оставляя значения без поворота.$ $Исходный Transformer добавляет позицию ко входу перед получением запросов, ключей и значений. RoPE поворачивает спроецированные запросы и ключи перед их скалярным произведением, оставляя значения без поворота.$

Для одной пары координат поворот — это умножение матрицы:

R(\varphi)=\begin{pmatrix} \cos\varphi&-\sin\varphi\\ \sin\varphi&\cos\varphi \end{pmatrix}.

$\varphi$ — угол поворота. Умножение этой матрицы на $(1,0)$ даёт $(\cos\varphi,\sin\varphi)$ ; при 90° это $(0,1)$ , то есть направленная вверх стрелка запроса на следующей диаграмме.

Почему поворот? Скалярное произведение зависит от угла между векторами. Поворот обоих векторов на один и тот же дополнительный угол не меняет их скалярного произведения. Если запрос на позиции 2 и ключ на позиции 3 переместятся на позиции 3 и 4, разность их позиций по-прежнему равна одному. При тех же исходных векторах содержания RoPE даёт ту же оценку:

\begin{aligned} &\bigl(R(m\theta)q\bigr)^\top\bigl(R(n\theta)k\bigr)\\ &\qquad=q^\top R\bigl((n-m)\theta\bigr)k. \end{aligned}

Здесь $q$ и $k$ — по одной паре координат запроса и ключа, $R$ поворачивает их, $m$ и $n$ — позиции токенов, а $\theta$ — угол поворота на позицию. Правая часть показывает полезное свойство: явный позиционный член использует разность $n-m$ . Оценка по-прежнему зависит от векторов содержания, а не только от расстояния.

На диаграмме оба исходных вектора равны $(1,0)$ , а поворот составляет 45° на позицию. Эти значения выбраны для примера: фиксированное содержание позволяет увидеть эффект сдвига обеих позиций.

$Две пары «запрос–ключ» с одинаковыми исходными векторами и одинаковой разностью позиций. Сдвиг обеих позиций одинаково поворачивает обе стрелки и сохраняет угол между ними и скалярное произведение.$ $Две пары «запрос–ключ» с одинаковыми исходными векторами и одинаковой разностью позиций. Сдвиг обеих позиций одинаково поворачивает обе стрелки и сохраняет угол между ними и скалярное произведение.$

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

Матрицы поворота и их вывод приведены в RoFormer v5, §3.2, уравнения (12)–(16). Подробный разбор RoPE содержит промежуточные алгебраические преобразования и числовые проверки.

MLA: хранить маленький вектор вместо ключей и значений

Attention heads существовали до MLA. Многоголовый аттеншн исходного Transformer, §3.2.2 выполняет несколько вычислений аттеншна с разными обученными проекциями и объединяет их выходы. DeepSeek сохраняет несколько attention heads. Меняется то, как представлены и кэшируются их ключи и значения.

При генерации обычный многоголовый аттеншн хранит ключ и значение каждого предыдущего токена для каждого attention head. Этот KV cache растёт вместе с последовательностью. Вместо этого MLA с помощью обученной проекции превращает входное представление токена непосредственно в один короткий вектор. Из него можно вычислить ключи содержания и значения всех attention heads. Все attention heads используют общий сохранённый вектор, но разные проекции и веса аттеншна; они не становятся одинаковыми.

Диаграмма показывает один токен от входного вектора до сохранённых данных в одном слое. С обеих сторон последующие запросы читают эти данные через несколько attention heads; их выходы объединяются в выход аттеншна.

$Обычный многоголовый аттеншн кэширует отдельные ключи и значения для каждого attention head. MLA кэширует один общий сжатый вектор и отдельный маленький позиционный ключ, сохраняя несколько attention heads.$ $Обычный многоголовый аттеншн кэширует отдельные ключи и значения для каждого attention head. MLA кэширует один общий сжатый вектор и отдельный маленький позиционный ключ, сохраняя несколько attention heads.$

Вычислению содержания на диаграмме соответствуют три уравнения из DeepSeek-V2:

\begin{aligned} c_t^{KV}&=W^{DKV}h_t,\\ k_t^C&=W^{UK}c_t^{KV},\\ v_t^C&=W^{UV}c_t^{KV}. \end{aligned}

$h_t$ — входной вектор токена $t$ . Первая строка преобразует его в более короткий кэшируемый вектор $c_t^{KV}$ . Следующие две преобразуют этот же вектор в ключи содержания и значения для всех attention heads. Верхние индексы — метки, а не степени: $DKV$ обозначает проекцию с уменьшением размерности, $UK$ и $UV$ — проекции с увеличением размерности для ключей и значений, а $C$ отмечает содержательную часть. Все три матрицы $W$ обучаются. Отдельный позиционный ключ находится за пределами этих трёх уравнений.

Для конфигурации DeepSeek-V2 сравнение составляет 32 768 чисел против 576: обычному аттеншну со 128 attention heads и 128 числами в каждом ключе и значении нужно $2\times128\times128$ ; MLA хранит сжатый вектор из 512 чисел и позиционный ключ из 64 чисел. Это примерно в 57 раз меньше кэшируемых чисел при одинаковой точности. Сравнивается эта конфигурация с обычным многоголовым аттеншном, а не со всеми вариантами кэша; это не означает ускорения инференса в 57 раз.

Не исчезнет ли преимущество, если разворачивать сжатый вектор каждого старого токена? MLA может избежать такого разворачивания. Для одного attention head сократим $c_t^{KV}$ до $c$ , а его строки $W^{UK}$ назовём матрицей разворачивания ключа $W_{\mathrm{up}}$ . Тогда:

q^\top(W_{\mathrm{up}}c)=(q^\top W_{\mathrm{up}})c.

Левая часть разворачивает каждый кэшируемый вектор в ключ перед сравнением с запросом $q$ . Правая часть один раз преобразует текущий запрос, затем сравнивает его непосредственно с кэшируемыми векторами. Это то же вычисление с другой группировкой. Для значений есть похожее преобразование: сначала усреднить сжатые векторы, затем применить выходные проекции. Реализация может выбрать порядок умножения, подходящий оборудованию.

RoPE требует отдельного рассмотрения. Поворот развёрнутых ключей содержания внёс бы в эту перегруппировку операцию, зависящую от позиции. Поэтому MLA оставляет эти ключи без поворота и добавляет отдельное сравнение запроса и ключа для позиции. Именно поэтому кэш содержит и сжатый вектор содержания, и маленький повёрнутый позиционный ключ.

MLA — обучаемая архитектура, а не компрессор без потерь, применимый к любому существующему слою аттеншна. DeepSeek-V2 v5, §2.1.2–2.1.3, уравнения (9)–(19) определяет проекции и отдельный компонент RoPE. Подробный разбор MLA даёт полные формы и перегруппировки матриц.

Разреженный аттеншн (DSA): дешёвый оценщик выбирает ключи

DSA уменьшает число токенов, участвующих в каждом вычислении аттеншна. Допустим, модель продолжает текст «The cat sat on a mat near me». В этом примере считайте каждое слово одним токеном. Модель обрабатывает последний токен, «me», на позиции 8.

Внутри одного слоя аттеншна представление текущего токена даёт вектор запроса. У каждого доступного токена есть ключ, с которым сравнивается запрос, и значение, которое передаёт информацию в выход. При генерации слой хранит данные аттеншна предыдущих токенов в своём KV cache, чтобы повторно использовать эти векторы. «Позиция 2» обозначает сохранённые данные для «cat»; кэш содержит числовые векторы, а не просто номера позиций. MLA хранит эти данные в описанном выше сжатом виде.

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

Дёшево оценить доступные токены. Небольшая обученная сеть, lightning indexer, использует собственные проекции запросов и ключей, чтобы оценить каждую позицию для текущего токена. Она оценивает, какие токены основной аттеншн будет использовать больше всего.
Выбрать позиции с наибольшими оценками. В примере «cat» и «mat» получают две наибольшие оценки индексатора. Выбор позиций 2 и 6 указывает основному аттеншну, какие сохранённые записи читать.
Вычислить аттеншн по этим записям. Основной аттеншн вычисляет собственные оценки запроса и ключа для выбранных записей, применяет softmax к этому подмножеству и объединяет их значения. Оценки индексатора выбирают записи; это не итоговые веса аттеншна.

Проследите столбец от текстового токена к его сохранённой записи, затем сравните плотное и разреженное вычисления. Все оценки и веса ниже приведены для иллюстрации.

$Восемь текстовых токенов соответствуют восьми сохранённым записям аттеншна в одном слое. Текущий токен — «me», на позиции 8. Плотный аттеншн использует все восемь записей. Отдельный индексатор DSA оценивает все позиции и выбирает «cat» на позиции 2 и «mat» на позиции 6, с оценками индексатора 0,8 и 0,9. Основной аттеншн затем вычисляет новые оценки и веса softmax по этим двум записям; один показанный attention head использует веса 0,7 и 0,3. Остальные записи остаются в кэше.$ $Восемь текстовых токенов соответствуют восьми сохранённым записям аттеншна в одном слое. Текущий токен — «me», на позиции 8. Плотный аттеншн использует все восемь записей. Отдельный индексатор DSA оценивает все позиции и выбирает «cat» на позиции 2 и «mat» на позиции 6, с оценками индексатора 0,8 и 0,9. Основной аттеншн затем вычисляет новые оценки и веса softmax по этим двум записям; один показанный attention head использует веса 0,7 и 0,3. Остальные записи остаются в кэше.$

Уравнение индексатора из статьи даёт первую строку оценок в блоке DSA:

I_{t,s}=\sum_{j=1}^{H^I}w^I_{t,j}\,\operatorname{ReLU}\bigl(q^I_{t,j}\cdot k^I_s\bigr).

$t$ — текущая позиция, а $s$ — позиция-кандидат. Верхний индекс $I$ отмечает собственные векторы индексатора. Для каждого из его $H^I$ attention heads сравните запрос $q^I_{t,j}$ с ключом $k^I_s$ , замените отрицательное скалярное произведение нулём с помощью ReLU, умножьте на обученный вес $w^I_{t,j}$ , зависящий от токена, и просуммируйте по attention heads $j$ . Результат $I_{t,s}$ — оценка для выбора.

Выбор и выход одного attention head основного аттеншна можно записать так:

\begin{aligned} \mathcal S_t&=\operatorname{TopKIndices}(I_{t,1:t},k),\\ u_t&=\sum_{s\in\mathcal S_t}a_{t,s}v_s. \end{aligned}

$I_{t,1:t}$ — строка оценок для доступных позиций от 1 до $t$ . TopKIndices возвращает позиции с наибольшими оценками, не более $k$ записей. Сумма читается «сложить взвешенные значения только для позиций в $\mathcal S_t$ ». Здесь $a_{t,s}$ — заново вычисленный вес softmax основного аттеншна, $v_s$ — его вектор значения, а $u_t$ — выход. На рисунке $\mathcal S_8=\{2,6\}$ и $u_8=0.7v_2+0.3v_6$ . Это переписывает обозначение выбранных записей из статьи в виде явной суммы; MLA может вычислить её в сжатом виде.

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

DeepSeek-V3.2 применяет DSA к сжатому кэшу MLA и выбирает до 2048 позиций на запрос. На последней позиции контекста из 131 072 токенов основной аттеншн читает одну запись из 64. Если доступно меньше 2048 позиций, он может использовать их все.

Экономия получается за счёт меньшего числа дорогих сравнений аттеншна. Индексатор по-прежнему оценивает каждую доступную позицию, но использует меньше attention heads и может вычислять в FP8. В последовательности длины $L$ число сравнений основного аттеншна уменьшается примерно с $L^2$ до $Lk$ , где $k$ — число выбранных записей. Работа индексатора над всеми парами остаётся квадратичной, поэтому метод в целом не является строго линейным по длине последовательности.

Уравнения оценивания и обучения приведены в DeepSeek-V3.2 v1, §2.1, уравнения (1)–(4) и подробном разборе DSA.

Gated DeltaNet: память фиксированного размера с перезаписью

Плотный аттеншн, MLA и DSA хранят растущий набор прошлых токенов. Вместо этого Gated DeltaNet обновляет одну матрицу фиксированного размера. Слой вычисляет ключ, значение и запрос из входных представлений токенов с помощью обученных проекций и коротких фильтров по соседним токенам. Ключ и значение обновляют матрицу; запрос читает обновлённую матрицу и получает выходной вектор. Он не может отдельно вернуться к ключу и значению каждого старого токена.

Полезно сравнить это с простой аддитивной памятью. Допустим, для некоторого ключа память сейчас возвращает 2, а следующий токен передаёт значение 5 для того же ключа. Прибавление нового значения дало бы 7. Дельта-обновление прибавляет поправку, $5-2$ , поэтому запись с полной силой даёт 5.

Пример использует ключ $(1,0)$ , который читает первый столбец матрицы: один первый столбец плюс ноль вторых. Выделенный столбец показывает поправку. После записи запрос $(1,0)$ читает из него $(5,0)$ . Размер матрицы не меняется.

$Аттеншн хранит растущий KV cache, а DeltaNet обновляет матрицу фиксированного размера. При исходных диагональных элементах 2 и 4 запись значения (5, 0) для ключа (1, 0) даёт первый элемент 7 при сложении или 5 при дельта-поправке. В примере нет затухания и используется полная сила записи; произвольные ключи могут влиять на другие сохранённые связи.$ $Аттеншн хранит растущий KV cache, а DeltaNet обновляет матрицу фиксированного размера. При исходных диагональных элементах 2 и 4 запись значения (5, 0) для ключа (1, 0) даёт первый элемент 7 при сложении или 5 при дельта-поправке. В примере нет затухания и используется полная сила записи; произвольные ключи могут влиять на другие сохранённые связи.$

Gated DeltaNet также учится определять, сколько старой памяти сохранять и насколько сильно применять каждую поправку:

S_t=\alpha_t S_{t-1}+\beta_t\bigl(v_t-\alpha_t S_{t-1}k_t\bigr)k_t^\top.

$S$ — матрица памяти, $k_t$ — текущий ключ единичной длины, а $v_t$ — его новое значение. Множитель $\alpha_t$ ослабляет старую память. Чтение ослабленной памяти с ключом $k_t$ даёт её текущий ответ; вычитание этого ответа из $v_t$ даёт поправку. Множитель $\beta_t$ управляет силой записи. Оба множителя вычисляются из текущего токена. Умножение обновлённой матрицы на запрос даёт результат чтения, который слой затем нормализует, модулирует и проецирует в свой выход. Пример с изменением 2 на 5 использует их предельное значение 1.

Фиксированная память экономит место, но записи могут мешать друг другу: изменение ответа для одного ключа может изменить ответ для другого, неортогонального ключа. Затухание тоже удаляет старую информацию. Это помогает объяснить, почему статья объединяет рекуррентные слои с аттеншном в скользящем окне в гибридных моделях, сохраняя отдельные записи для недавних токенов.

Показанная форма перегруппирует Gated Delta Networks v3, §3.1, уравнение (10). Подробный разбор выводит её и показывает обновление матрицы.

Роутинг MoE: смещение выбирает экспертов, оценка задаёт веса

Слой смеси экспертов (MoE) содержит несколько сетей прямого распространения, которые называют экспертами, и выбирает лишь некоторые для каждого токена. Это увеличивает ёмкость модели без запуска каждого эксперта для каждого входа. Меняется часть Transformer с сетью прямого распространения, а не его attention heads.

Конкретное правило роутинга DeepSeek-V3 разделяет два решения: какие эксперты запускаются и каков вес их выходов. Обученный роутер получает вектор текущего токена и даёт каждому эксперту оценку $s_i$ . Смещение балансировки нагрузки $b_i$ меняет оценку для выбора на $s_i+b_i$ . После выбора выходные веса вычисляются из исходных оценок, нормализованных по выбранным экспертам. Смещение в эти веса не входит.

В примере выбираются два из четырёх экспертов. У эксперта 1 наибольшая исходная оценка, но отрицательное смещение исключает его; вместо него запускаются эксперты 2 и 3. Оба получают один и тот же вектор токена $x$ . Каждый выдаёт новый вектор, обозначенный $E_2(x)$ или $E_3(x)$ , а слой складывает эти выходы с весами 0,56 и 0,44. Диаграмма показывает только этот вклад выбираемых экспертов.

$Четыре эксперта ранжируются по сумме оценки и смещения для выбора экспертов 2 и 3. Их исходные оценки, 0,5 и 0,4, определяют выходные веса около 0,56 и 0,44.$ $Четыре эксперта ранжируются по сумме оценки и смещения для выбора экспертов 2 и 3. Их исходные оценки, 0,5 и 0,4, определяют выходные веса около 0,56 и 0,44.$

Компактная форма правила роутинга DeepSeek-V3 для одного токена:

\begin{aligned} \mathcal E&=\operatorname{TopKIndices}(s+b,K),\\ g_i&=\begin{cases} \dfrac{s_i}{\sum_{j\in\mathcal E}s_j},&i\in\mathcal E,\\ 0,&i\notin\mathcal E, \end{cases}\\ u_{\mathrm{routed}}&=\sum_i g_iE_i(x). \end{aligned}

$s$ и $b$ собирают оценки и смещения всех экспертов; $K$ — число выбираемых экспертов. Первая строка возвращает индексы выбранных экспертов $\mathcal E$ . Фигурная скобка во второй строке — это if/else: разделить исходную оценку выбранного эксперта на сумму выбранных оценок или присвоить ноль, если эксперт не выбран. Последняя строка складывает выходные векторы экспертов с этими весами. На рисунке $\mathcal E=\{2,3\}$ , поэтому $g_2=0.5/(0.5+0.4)\approx0.56$ и $g_3\approx0.44$ . Смещение появляется только при выборе. Вклады остаточного соединения и общего эксперта не входят в $u_{\mathrm{routed}}$ .

При обучении смещение слишком часто используемого эксперта уменьшается, а слишком редко используемого — увеличивается. Это способствует более равномерной нагрузке. DeepSeek-V3 также сохраняет небольшие балансирующие потери для каждой последовательности, поэтому «auxiliary-loss-free» не означает полного отсутствия балансирующих потерь.

Его конфигурация активирует 8 из 256 выбираемых экспертов на токен плюс одного общего эксперта, который запускается всегда. Эти числа и общий эксперт относятся к данной модели, а не к определению MoE. См. DeepSeek-V3 v2, §2.1.2, уравнения (12)–(17) и разбор роутинга.

mHC: остаточное смешивание ограничено взвешенными средними

Обычное остаточное соединение передаёт вектор токена в обход подслоя и добавляет к нему результат подслоя. mHC поддерживает несколько таких векторов, называемых остаточными потоками, и меняет их смешивание между слоями. Идеальная матрица смешивания имеет неотрицательные элементы с суммами строк и столбцов, равными единице. Такое смешивание образует взвешенные средние, сохраняя сумму по потокам. Реализация приближённо выполняет это ограничение конечным числом шагов нормализации; она не ограничивает каждую операцию в сети.

Отдельная статья о mHC объясняет механизм, нормализацию и ограничения с диаграммами. Для этой темы используйте её; разбор уравнения содержит вывод.

LoRA: низкоранговое обновление рядом с замороженным весом

Полный файн-тюнинг обновляет матрицы весов модели. LoRA замораживает предобученную матрицу $W_0$ и обучает рядом с ней меньшую поправку:

h=W_0x+BAx.

$x$ — вектор токена на входе выбранного линейного слоя, а $h$ — выходной вектор, который передаётся дальше по модели. Исходное умножение $W_0x$ по-прежнему выполняется. В поправке $A$ отображает вход в гораздо меньший вектор, а $B$ возвращает его к размеру выхода. Обучающие примеры и потери задачи определяют обновления $A$ и $B$ ; $W_0$ остаётся фиксированной. Их общая малая размерность — настройка ранга $r$ ; полученное обновление $BA$ имеет ранг не выше $r$ .

Для матрицы весов $4096\times4096$ и $r=8$ полное обновление содержит около 16,8 миллиона элементов. Две матрицы LoRA содержат $4096\times8+8\times4096=65{,}536$ : в 256 раз меньше обучаемых элементов для этой матрицы. Это уменьшает память для градиентов и состояния оптимизатора, но полный базовый вес по-прежнему занимает память и участвует в вычислении.

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

$Полный файн-тюнинг обучает все 16 777 216 элементов веса 4096 на 4096. LoRA замораживает этот вес и добавляет параллельный путь через матрицу A 8 на 4096 и матрицу B 4096 на 8. Их 65 536 элементов обучаются; промежуточный вектор из восьми чисел ограничивает ранг поправки. Оба пути дают 4096 чисел, которые складываются.$ $Полный файн-тюнинг обучает все 16 777 216 элементов веса 4096 на 4096. LoRA замораживает этот вес и добавляет параллельный путь через матрицу A 8 на 4096 и матрицу B 4096 на 8. Их 65 536 элементов обучаются; промежуточный вектор из восьми чисел ограничивает ранг поправки. Оба пути дают 4096 чисел, которые складываются.$

В исходном методе $B$ начинается с нуля, поэтому поправка сначала ничего не меняет. Статья масштабирует обновление на $\alpha/r$ — настройку, опущенную в её уравнении (3) выше. После обучения масштабированную поправку можно добавить к $W_0$ ; объединённому слою требуется только исходное матричное умножение. Отдельные адаптеры добавляют вычисления, но позволяют заменять их.

См. LoRA v2, §4.1, уравнение (3) и подробный разбор LoRA. QLoRA дополнительно хранит замороженные базовые веса в 4-битном виде и деквантизирует их для вычислений; это не делает всю память обучения 4-битной. Руководство по файн-тюнингу сравнивает практические варианты.

Дополнительные разборы уравнений

Разборы уравнений по ссылке содержат определения символов, промежуточные выводы и проверки на маленьких числах. Они подготовлены с помощью инструкций для агентов программирования из paper-math-skills. Это дополнительные объяснения; первичные источники — статьи, на которые даны ссылки рядом с каждым механизмом.

Источники и версии

Ссылки на статьи выше указывают версии, использованные для номеров разделов и уравнений. Исходный вариант аттеншна описан в Attention Is All You Need v7, §3.2 и §3.5. Отдельная тема остаточного смешивания рассмотрена в mHC v2.