дорожка · 08.11.2026 · низкоранговая адаптация

Как дообучить большую модель, не трогая все веса: низкоранговая адаптация

Вчерашняя дорожка про скользящее среднее весов была про обучение с нуля: все веса учатся, рядом ведётся спокойная копия. Сегодня другая ситуация: большая модель уже обучена, и нужно изменить её поведение под свою задачу, не обновляя миллиарды параметров. Самый распространённый способ — низкоранговая адаптация (Low-Rank Adaptation, LoRA): исходная матрица весов замораживается, а рядом учится маленькая добавка в виде произведения двух узких матриц. Когда дообучение вообще нужно, а когда хватит подсказки или поиска, мы разбирали 15 октября; здесь — механика самой добавки: из чего она состоит, сколько стоит, как её настраивать, сливать и где она ломается. Все примеры ниже запускались в numpy на коробке, цифры — из этих запусков. Утверждения статей помечены как опубликованные, а не измеренные нами.

Все дорожки — /put. Прошлая — EMA весов.

1 Зачем не учить все веса: память, много задач на одной базе

Зачем это в работе. Полное дообучение (full fine-tuning) — это то же обучение, только стартующее с готовых весов: оптимизатор обновляет каждый параметр модели. Для модели на 7 миллиардов параметров это значит держать в памяти не только веса, но и их градиенты, главную копию и два момента Adam — по формуле из дорожки про смешанную точность около 16 байт на параметр, то есть порядка 112 ГБ ещё до активаций. Вторая боль — хранение: если у вас пять задач (поддержка, юридические письма, код, разметка, перевод), полное дообучение даёт пять полных копий модели. Низкоранговая адаптация решает обе проблемы: исходные веса не меняются, а учится маленькая добавка, которую можно хранить отдельным файлом и подключать к одной и той же базе.

Как это устроено. Возьмём одну матрицу весов слоя W размером d×k: она переводит вход длины k в выход длины d (например, проекция запросов во внимании). Полное дообучение заменило бы её на W + ΔW, где ΔW — такая же большая матрица d×k, и учило бы все d·k чисел. LoRA предлагает искать ΔW в виде произведения B·A, где A имеет размер r×k, B — d×r, а ранг r (rank) — маленькое число, например 8 или 16. Ранг матрицы — это число независимых направлений, которые она умеет различать; произведение B·A по построению имеет ранг не больше r. Тогда вместо d·k чисел учится r·(d+k).

Почему это вообще должно работать. Идея опубликована у Hu и соавторов (LoRA: Low-Rank Adaptation of Large Language Models, 2021, конференция ICLR 2022). Они опирались на более ранние работы о том, что у предобученных моделей «внутренняя размерность» задачи дообучения мала, и выдвинули гипотезу: изменение весов при адаптации тоже имеет низкий «внутренний ранг» (intrinsic rank). Это утверждение статей, а не закон природы: для сильного сдвига, например нового языка или новой области знаний, маленького ранга может не хватить — об этом ступени 3 и 5.

Ограничение, которое часто упускают: замороженные веса всё равно участвуют в прямом и обратном проходе. Градиент по W не хранится и не применяется, но сигнал ошибки проходит сквозь W к нижним слоям, а активации (промежуточные результаты прямого прохода) по-прежнему занимают память. LoRA экономит память оптимизатора и градиентов весов, а не вычисления прямого прохода.

Чем это отличается от соседних понятий. Подсказка (prompt) меняет вход модели, поиск с подстановкой документов (RAG) добавляет во вход найденный текст; веса при этом не меняются, и модель ведёт себя так же на всём, что не попало в контекст. LoRA меняет саму функцию — то, как слой переводит вход в выход, — и это изменение действует без длинных инструкций в каждом запросе. От полного дообучения LoRA отличается тем, что меняется только маленькая часть параметров, а база остаётся байт в байт той же.

Подробный пример. Посчитаем размеры для матрицы 4096×4096 — такой размер у проекций внимания в моделях шириной 4096. Затем возьмём условную модель на 7 миллиардов параметров с 32 блоками, где все четыре проекции внимания (Q, K, V, O) квадратные 4096×4096, и сравним память: полное дообучение по 16 байт на параметр против замороженной базы в bf16 (2 байта на параметр) плюс 16 байт только на обучаемые параметры адаптера. Конфигурация упрощённая (в реальных моделях K и V часто меньше), активации не считаем.

import numpy as np
d, k = 4096, 4096          # размер проекции внимания (вход k, выход d)
full = d * k
print(f"матрица W {d}x{k}: {full:,} параметров".replace(",", " "))
for r in (8, 16, 64):
    lora = r * (d + k)      # A: r x k, B: d x r
    print(f"  r={r:3d}: A+B = {lora:>10,} параметров = {100*lora/full:.3f}% от W".replace(",", " "))

# Модель-пример: 32 блока, ширина 4096, всего 7 млрд параметров (условная конфигурация)
N_total = 7_000_000_000
layers = 32
B_ADAM = 16      # байт на обучаемый параметр: bf16 вес + bf16 градиент + fp32 главная копия + 2 момента fp32
B_BF16 = 2       # байт на замороженный параметр в bf16
GB = 1e9
print(f"\nполное дообучение: {N_total*B_ADAM/GB:.0f} ГБ (16 байт x 7 млрд, без активаций)")
for name, mats in (("Q,V", 2), ("Q,K,V,O", 4)):
    for r in (8, 16):
        n_tr = layers * mats * r * (d + k)
        mem = N_total * B_BF16 + n_tr * B_ADAM
        print(f"адаптер на {name:7s} r={r:2d}: обучаемых {n_tr/1e6:5.1f} млн "
              f"({100*n_tr/N_total:.3f}%), их Adam-память {n_tr*B_ADAM/GB:5.2f} ГБ, "
              f"+ замороженная база {N_total*B_BF16/GB:.0f} ГБ = {mem/GB:.1f} ГБ")
n_tr = layers * 4 * 16 * (d + k)
print(f"\nфайл адаптера (Q,K,V,O, r=16) в bf16: {n_tr*2/1e6:.0f} МБ; файл базы в bf16: {N_total*2/GB:.0f} ГБ")

У нас этот код напечатал:

матрица W 4096x4096: 16 777 216 параметров
  r=  8: A+B =     65 536 параметров = 0.391% от W
  r= 16: A+B =    131 072 параметров = 0.781% от W
  r= 64: A+B =    524 288 параметров = 3.125% от W

полное дообучение: 112 ГБ (16 байт x 7 млрд, без активаций)
адаптер на Q,V     r= 8: обучаемых   4.2 млн (0.060%), их Adam-память  0.07 ГБ, + замороженная база 14 ГБ = 14.1 ГБ
адаптер на Q,V     r=16: обучаемых   8.4 млн (0.120%), их Adam-память  0.13 ГБ, + замороженная база 14 ГБ = 14.1 ГБ
адаптер на Q,K,V,O r= 8: обучаемых   8.4 млн (0.120%), их Adam-память  0.13 ГБ, + замороженная база 14 ГБ = 14.1 ГБ
адаптер на Q,K,V,O r=16: обучаемых  16.8 млн (0.240%), их Adam-память  0.27 ГБ, + замороженная база 14 ГБ = 14.3 ГБ

файл адаптера (Q,K,V,O, r=16) в bf16: 34 МБ; файл базы в bf16: 14 ГБ

Адаптер ранга 8 на одной матрице — 65 536 чисел, 0,391% от 16,8 миллиона. Даже на всех четырёх проекциях всех 32 блоков при r = 16 обучается 16,8 миллиона параметров (0,24% модели), и их состояние Adam занимает около 0,27 ГБ. Основную память теперь съедает замороженная база — 14 ГБ в bf16, — а не оптимизатор: 14,3 ГБ против 112 ГБ. Файл адаптера весит около 34 МБ, поэтому десять задач — это одна база на 14 ГБ и десять маленьких файлов. Заметь совпадение: адаптер r = 16 на всех 128 проекциях — ровно столько же чисел, сколько одна полная матрица 4096×4096. Повтори: поставь r = 64 и посчитай долю модели и память Adam для адаптера на Q, K, V, O.

Где обычно ошибаются.

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

Полное дообучение (full fine-tuning). Продолжение обучения, в котором обновляются все веса модели.

Замороженные веса (frozen weights). Параметры, которые участвуют в вычислениях, но не обновляются оптимизатором.

Адаптер (adapter). Небольшой набор обучаемых параметров, который подключают к замороженной базе, чтобы изменить её поведение.

Ранг матрицы (rank). Число независимых направлений, которые матрица переводит во что-то ненулевое.

Ранг адаптера r. Ширина «горлышка» между A и B; задаёт, сколько направлений изменения может выучить адаптер.

Параметрически экономное дообучение (parameter-efficient fine-tuning, PEFT). Общее название методов, которые учат малую долю параметров; LoRA — самый распространённый из них.

Базовая модель (base model). Готовая предобученная модель, которую не меняют, а только дополняют адаптерами.

2 Как устроена добавка: y = Wx + B(Ax), и почему B стартует нулями

Зачем это в работе. Когда вы читаете конфиг адаптера или отлаживаете странное поведение после дообучения, нужно понимать, что именно делает слой с адаптером на каждом входе. От этого зависит, почему модель в первый шаг дообучения ведёт себя ровно как база, почему обучение может вообще не сдвинуться с места и почему после обучения адаптер можно «впаять» в веса.

Как это устроено. Обычный линейный слой считает y = Wx. Слой с адаптером считает y = Wx + B(Ax): вход x сначала сжимается матрицей A до вектора длины r (это «узкое горлышко»), затем матрица B разворачивает его обратно до длины d, и результат прибавляется к выходу базы. Математически это то же самое, что (W + BA)x, то есть адаптер — это низкоранговая поправка к матрице W. Порядок умножения важен для скорости: во время обучения считают B(Ax), не собирая большую матрицу BA, — так дешевле.

Старт. В статье Hu и соавторов A инициализируют случайными числами, а B — нулями. Тогда BA = 0, и в самом начале выход слоя с адаптером в точности совпадает с выходом базы: дообучение начинается с того поведения, которое уже есть, а не с испорченного случайной поправкой. Почему не обе нулями: градиент по B пропорционален Ax, а градиент по A пропорционален B; если обе матрицы нулевые, оба градиента нулевые, и обучение не сдвинется ни на шаг. Одна случайная матрица ломает эту симметрию, а нулевая вторая сохраняет равенство с базой на старте.

Что считает оптимизатор. Градиент берут только по A и B; W заморожена, её градиент не хранится и не применяется. Обычно к A и B применяют тот же оптимизатор, что и при обычном обучении (как правило, AdamW из дорожки 29 октября), только параметров у него в сотни раз меньше.

Чем это отличается от соседнего. Если просто добавить к сети новый маленький слой, он стоит в цепочке последовательно, и его нельзя убрать без потери поведения; поправка BA стоит параллельно W и складывается с ней, поэтому её можно слить в одну матрицу (ступень 4). От «обрезки» матрицы (low-rank factorization самой W) LoRA отличается тем, что исходная W остаётся целой, низкоранговой делается только поправка.

Подробный пример. Линейный слой 64×64 с «обученной» базой W. Новая задача — сдвиг поведения ранга 4: целевые выходы Y = (W + ΔW)X на 2000 случайных входах. Адаптер ранга 4: A случайно, B нулями, обычный градиентный спуск с шагом 0,05. Проверяем три вещи: на старте выход равен базе; после обучения поправка BA совпадает с целевым сдвигом, а W не изменилась; при старте с обеих нулевых матриц обучение стоит.

import numpy as np
rng = np.random.default_rng(0)
d, k, r, n = 64, 64, 4, 2000
W = rng.standard_normal((d, k)) / np.sqrt(k)          # «обученная» база, заморожена
W_saved = W.copy()
# целевой сдвиг поведения: ранг 4 (новая задача)
U = rng.standard_normal((d, 4)); V = rng.standard_normal((4, k))
dW_true = 0.5 * (U @ V) / np.sqrt(k * 4)
X = rng.standard_normal((k, n))                         # входы — столбцы
Y = (W + dW_true) @ X                                   # что хотим получить

def train(A, B, steps=600, lr=0.05, s=1.0):
    for t in range(steps + 1):
        H = A @ X                                       # r x n — «узкое горлышко»
        E = W @ X + s * (B @ H) - Y                     # ошибка выхода
        if t in (0, 50, 200, 600):
            print(f"  шаг {t:4d}: потеря {np.mean(E**2):.3e}")
        gB = s * (2 / n) * E @ H.T                      # градиент только по B и A,
        gA = s * (2 / n) * B.T @ E @ X.T                # по W его не считаем
        B -= lr * gB; A -= lr * gA
    return A, B

A = rng.standard_normal((r, k)) / np.sqrt(k)            # A — случайно
B = np.zeros((d, r))                                    # B — нулями
x = X[:, :5]
print("старт: max|выход с адаптером − выход базы| =", np.abs((W + B @ A) @ x - W @ x).max())
print(f"потеря самой базы на новой задаче: {np.mean((W @ X - Y)**2):.6f}")
print("обучение A (случайно) и B (нули):")
A, B = train(A, B)
print("W не изменилась:", np.array_equal(W, W_saved))
print(f"‖BA − ΔW_true‖ / ‖ΔW_true‖ = {np.linalg.norm(B@A - dW_true)/np.linalg.norm(dW_true):.2e}")
print(f"ранг BA = {np.linalg.matrix_rank(B @ A)}")

print("\nобе матрицы нулями:")
A0, B0 = train(np.zeros((r, k)), np.zeros((d, r)), steps=200)
print("обе случайные (старт не равен базе):")
A1 = rng.standard_normal((r, k)) / np.sqrt(k); B1 = rng.standard_normal((d, r)) / np.sqrt(r)
print(f"  старт: max|выход − база| = {np.abs(B1 @ A1 @ x).max():.3f}")

У нас этот код напечатал:

старт: max|выход с адаптером − выход базы| = 0.0
потеря самой базы на новой задаче: 0.255290
обучение A (случайно) и B (нули):
  шаг    0: потеря 2.553e-01
  шаг   50: потеря 1.681e-03
  шаг  200: потеря 3.749e-14
  шаг  600: потеря 2.532e-31
W не изменилась: True
‖BA − ΔW_true‖ / ‖ΔW_true‖ = 5.57e-16
ранг BA = 4

обе матрицы нулями:
  шаг    0: потеря 2.553e-01
  шаг   50: потеря 2.553e-01
  шаг  200: потеря 2.553e-01
обе случайные (старт не равен базе):
  старт: max|выход − база| = 2.695

На старте разница с базой ровно 0,0 — поведение не изменилось. База ошибается на новой задаче с потерей 0,2553; к шагу 50 потеря 0,0017, к шагу 200 практически ноль. Поправка BA совпала с целевым сдвигом до ошибок округления (относительная ошибка 5,6·10−16), её ранг ровно 4, а W побайтно та же. Если обнулить обе матрицы, потеря стоит на 0,2553 все 200 шагов. Если обе взять случайными, уже на старте выход отличается от базы до 2,7 по модулю — дообучение начинается с порчи. Повтори: поставь r = 2 при том же целевом сдвиге ранга 4 и посмотри, где остановится потеря.

Где обычно ошибаются.

  • Своя реализация инициализирует обе матрицы нулями «для безопасности», и обучение не двигается.
  • Инициализируют обе матрицы случайно и удивляются, что модель после первого шага уже хуже базы.
  • Забывают заморозить W (оставляют requires_grad включённым): память оптимизатора возвращается к полному дообучению, а экономию никто не замечает до падения по памяти.

Низкоранговая поправка. Изменение матрицы, записанное как произведение BA двух узких матриц.

Матрица A (down-projection). Сжимает вход длины k до вектора длины r; стартует случайной.

Матрица B (up-projection). Разворачивает вектор длины r до длины выхода d; стартует нулями.

Узкое горлышко (bottleneck). Промежуточный вектор Ax длины r, через который проходит вся поправка.

Нарушение симметрии. Случайный старт хотя бы одной матрицы, без которого градиенты A и B остаются нулевыми.

Заморозка (requires_grad=False). Флаг, который запрещает считать и применять градиент к параметру.

3 Ранг r, масштаб alpha/r и какие матрицы трогать

Зачем это в работе. В конфиге адаптера почти всегда три решения: ранг r, коэффициент alpha и список матриц (target modules), к которым адаптер цепляется. Ранг определяет, какой сложности сдвиг поведения адаптер вообще способен выучить; alpha — насколько сильно добавка влияет на выход; список матриц — где в сети живут изменения. Ошибиться можно в каждом пункте, и симптомы похожи: «дообучение почти ничего не дало» или «модель поплыла».

Как это устроено: ранг. Любую матрицу можно разложить по сингулярным числам (SVD): это набор независимых направлений с «силами», упорядоченными по убыванию. Теорема Эккарта–Янга говорит, что лучшая приближённая матрица ранга r по сумме квадратов ошибок — это первые r направлений, а остаток равен корню из суммы квадратов отброшенных сил. Значит, если нужный сдвиг весов имеет больше значимых направлений, чем r, адаптер не может выучить его точно, как бы долго ни учился. Это и есть потолок, который задаёт r.

Как это устроено: масштаб. В статье Hu и соавторов выход поправки умножают на s = alpha/r: слой считает Wx + (alpha/r)·B(Ax). Авторы пишут, что при обучении с Adam подбор alpha примерно равносилен подбору скорости обучения, поэтому они ставили alpha равным первому опробованному r и больше его не трогали. Смысл множителя — чтобы при смене r размах добавки не менялся слишком сильно и не приходилось заново подбирать скорость обучения. В примере ниже видно, что это работает лишь приближённо и зависит от оптимизатора. Позже опубликован вариант rsLoRA (Kalajdzievski, 2023) с множителем alpha/√r, который, по утверждению автора, лучше ведёт себя на больших рангах; в библиотеке PEFT его включает флаг use_rslora.

Как это устроено: какие матрицы. В трансформере есть проекции внимания Q, K, V, O и матрицы полносвязного блока (MLP, см. дорожку 2 ноября). В исходной статье LoRA основные опыты ставили на проекциях внимания, и при фиксированном бюджете параметров лучшим оказалось адаптировать Q и V вместе. Авторы QLoRA (Dettmers и соавторы, 2023) опубликовали, что для качества, сравнимого с полным дообучением, адаптеры нужно ставить на все линейные слои блока, включая MLP. Практический вывод: Q и V — дешёвый минимум, все линейные слои — более сильный и более дорогой вариант; знания чаще связывают с MLP, но это не догма.

Чем ранг отличается от alpha. Ранг меняет форму возможных поправок — сколько независимых направлений доступно. Alpha меняет только громкость уже выученной поправки. Большой alpha не заменит недостающий ранг, а большой ранг не исправит слишком тихую добавку.

Подробный пример, часть 1: потолок ранга. Слой 64×64, целевой сдвиг ранга 8 с силами 3; 2,5; 2; 1,5; 1; 0,7; 0,4; 0,2. Обучаем адаптеры с r = 1, 2, 4, 6, 8, 16 (3000 шагов градиентного спуска) и сравниваем относительную ошибку ‖BA − ΔW‖/‖ΔW‖ с теоретическим минимумом по SVD.

import numpy as np
rng = np.random.default_rng(1)
d = k = 64; n = 2000
W = rng.standard_normal((d, k)) / np.sqrt(k)
# целевой сдвиг ранга 8 с убывающими «силами» направлений
U, _ = np.linalg.qr(rng.standard_normal((d, 8)))
V, _ = np.linalg.qr(rng.standard_normal((k, 8)))
svals = np.array([3.0, 2.5, 2.0, 1.5, 1.0, 0.7, 0.4, 0.2])
dW = U @ np.diag(svals) @ V.T
print("сингулярные числа ΔW:", np.round(np.linalg.svd(dW, compute_uv=False)[:10], 3))
X = rng.standard_normal((k, n)); Y = (W + dW) @ X

def train(r, steps=3000, lr=0.02, seed=0):
    g = np.random.default_rng(seed)
    A = g.standard_normal((r, k)) / np.sqrt(k); B = np.zeros((d, r))
    for _ in range(steps):
        H = A @ X; E = W @ X + B @ H - Y
        gB = (2/n) * E @ H.T; gA = (2/n) * B.T @ E @ X.T
        B -= lr * gB; A -= lr * gA
    return np.linalg.norm(B @ A - dW) / np.linalg.norm(dW)

print("\n r | обучили адаптер | лучший возможный (SVD)")
for r in (1, 2, 4, 6, 8, 16):
    best = np.sqrt(np.sum(svals[r:]**2)) / np.linalg.norm(dW)
    print(f"{r:2d} |     {train(r):.4f}      |     {best:.4f}")

У нас этот код напечатал:

сингулярные числа ΔW: [3.  2.5 2.  1.5 1.  0.7 0.4 0.2 0.  0. ]

 r | обучили адаптер | лучший возможный (SVD)
 1 |     0.7823      |     0.7822
 2 |     0.5853      |     0.5851
 4 |     0.2703      |     0.2700
 6 |     0.0931      |     0.0929
 8 |     0.0033      |     0.0000
16 |     0.0010      |     0.0000

При r меньше 8 обученный адаптер останавливается ровно на пределе Эккарта–Янга: r = 4 даёт 0,2703 при минимуме 0,2700, r = 6 — 0,0931 при 0,0929. Никакое дополнительное обучение тут не поможет — не хватает направлений. С r = 8 и r = 16 предел нулевой; остаток 0,0033 и 0,0010 — это самое слабое направление (сила 0,2), которое градиентный спуск доучивает медленнее всего. Лишний ранг (16 при нужных 8) не мешает, но и не нужен.

Часть 2: что делает множитель. Та же задача, alpha = 16. Меняем r от 4 до 64 и измеряем размах добавки ‖s·BA‖ после первых 10 шагов: без множителя (s = 1), с s = alpha/r и с s = alpha/√r. Два оптимизатора: обычный градиентный спуск и Adam.

import numpy as np
rng = np.random.default_rng(1)
d = k = 64; n = 2000
W = rng.standard_normal((d, k)) / np.sqrt(k)
U, _ = np.linalg.qr(rng.standard_normal((d, 8)))
V, _ = np.linalg.qr(rng.standard_normal((k, 8)))
dW = U @ np.diag([3.0, 2.5, 2.0, 1.5, 1.0, 0.7, 0.4, 0.2]) @ V.T
X = rng.standard_normal((k, n)); Y = (W + dW) @ X
alpha = 16

def size_after(r, s, opt, steps=10):
    g = np.random.default_rng(0)
    A = g.standard_normal((r, k)) / np.sqrt(k); B = np.zeros((d, r))
    mA = np.zeros_like(A); vA = np.zeros_like(A); mB = np.zeros_like(B); vB = np.zeros_like(B)
    for t in range(1, steps + 1):
        H = A @ X; E = W @ X + s * B @ H - Y
        gB = s * (2/n) * E @ H.T; gA = s * (2/n) * B.T @ E @ X.T
        if opt == "sgd":
            B -= 0.002 * gB; A -= 0.002 * gA
        else:                                   # Adam, lr=1e-3, β1=0.9, β2=0.999
            for P, G, m, v in ((B, gB, mB, vB), (A, gA, mA, vA)):
                m[:] = 0.9 * m + 0.1 * G; v[:] = 0.999 * v + 0.001 * G * G
                P -= 1e-3 * (m / (1 - 0.9**t)) / (np.sqrt(v / (1 - 0.999**t)) + 1e-8)
    return np.linalg.norm(s * B @ A)

for opt in ("sgd", "adam"):
    print(f"\n{opt.upper()}: ‖s·BA‖ после 10 шагов, alpha={alpha}")
    print("  r |   s=1   | s=alpha/r | s=alpha/√r")
    for r in (4, 8, 16, 32, 64):
        a = size_after(r, 1.0, opt); b = size_after(r, alpha / r, opt); c = size_after(r, alpha / np.sqrt(r), opt)
        print(f" {r:2d} | {a:7.4f} |  {b:7.4f}  |  {c:7.4f}")

У нас этот код напечатал:

SGD: ‖s·BA‖ после 10 шагов, alpha=16
  r |   s=1   | s=alpha/r | s=alpha/√r
  4 |  0.0501 |   0.5914  |   1.1216
  8 |  0.0740 |   0.2775  |   1.3148
 16 |  0.1028 |   0.1028  |   1.1632
 32 |  0.1729 |   0.0443  |   1.1063
 64 |  0.2743 |   0.0179  |   0.9583

ADAM: ‖s·BA‖ после 10 шагов, alpha=16
  r |   s=1   | s=alpha/r | s=alpha/√r
  4 |  0.1638 |   0.5692  |   0.9576
  8 |  0.2399 |   0.4591  |   1.0875
 16 |  0.3511 |   0.3511  |   1.1883
 32 |  0.5472 |   0.2806  |   1.3784
 64 |  0.8608 |   0.2262  |   1.5934

Без множителя размах растёт с рангом: от r = 4 до r = 64 примерно в 5,5 раза при градиентном спуске и в 5,3 раза при Adam. С Adam множитель alpha/r заметно сужает разброс (0,57 → 0,23, то есть в 2,5 раза в обратную сторону), а alpha/√r — ещё сильнее (0,96 → 1,59, в 1,7 раза). При обычном градиентном спуске alpha/r перекомпенсирует: размах падает в 33 раза, а alpha/√r держится около единицы. Вывод на практике: при смене r с конвенцией alpha/r нужно перепроверить скорость обучения, а при сравнении запусков — знать, какой множитель стоит в вашей библиотеке. Повтори: поставь в Adam шаг 1e-4 и посмотри, сохраняется ли порядок столбцов.

Где обычно ошибаются.

  • Поднимают r, чтобы «модель выучила больше», а alpha оставляют тем же: при alpha/r добавка становится тише, и обучение выглядит медленнее.
  • Ставят адаптер только на Q и V для задачи, которой нужны новые знания, и решают, что LoRA «не умеет»; иногда достаточно добавить MLP.
  • Сравнивают запуски из разных библиотек, не заметив, что в одной множитель alpha/r, а в другой alpha/√r.

Сингулярное разложение (SVD). Запись матрицы как суммы независимых направлений с убывающими «силами» — сингулярными числами.

Теорема Эккарта–Янга. Лучшее приближение матрицы рангом r — первые r направлений SVD; ошибка — корень из суммы квадратов остальных сил.

Alpha (lora_alpha). Константа, задающая громкость поправки через множитель alpha/r.

Множитель s = alpha/r. Число, на которое умножают B(Ax) перед сложением с выходом базы.

rsLoRA. Вариант с множителем alpha/√r, опубликованный для устойчивости на больших рангах.

Целевые модули (target modules). Список матриц модели, к которым подключают адаптер, например q_proj и v_proj.

Проекции внимания Q, K, V, O. Четыре матрицы слоя внимания: запросы, ключи, значения и выходная проекция.

4 После обучения: слияние, несколько адаптеров на одной базе, QLoRA и соседи

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

Как это устроено: слияние (merge). Раз слой считает Wx + s·B(Ax) = (W + s·BA)x, можно один раз посчитать W′ = W + s·BA и дальше пользоваться W′ как обычной матрицей. Выход будет тем же до ошибок округления, а цена вывода — ровно как у базы: никаких лишних умножений, никакой задержки. Это главное практическое преимущество LoRA, на которое указывают Hu и соавторы: в отличие от многих других адаптеров, она не добавляет задержки при выводе, если её слить.

Как это устроено: переключение без слияния. Если база общая, а задач много, адаптеры держат отдельно: на каждый запрос к выходу базы прибавляют s·B(Ax) нужного адаптера. Это стоит немного лишних вычислений (r·(d+k) умножений на вход в каждом слое), но позволяет одной копии базы в памяти обслуживать десятки задач; серверы вывода умеют собирать в один пакет запросы к разным адаптерам. Слить можно только один адаптер на копию весов: два адаптера, обученных на разные задачи, складывать «на всякий случай» нельзя — каждый учился исправлять базу, а не базу плюс соседа.

Ограничение слияния: точность чисел. Если база хранится в 16-битном формате, после W′ = W + s·BA результат округляется, и вычесть адаптер обратно, чтобы получить исходную W побайтно, уже не получится. Поэтому исходную базу держат отдельным файлом, а не «размердживают» слитую копию. Ещё сильнее это касается квантованной базы: слить адаптер в 4-битные веса — значит заново квантовать результат и потерять часть того, что выучил адаптер.

Соседние понятия. QLoRA (Dettmers и соавторы, 2023): база хранится в 4 битах (квантование мы разбирали 18 октября), адаптеры учатся в более точных 16-битных числах, а градиент проходит сквозь замороженную квантованную базу; это позволяет дообучать большие модели на одной видеокарте. Адаптеры Houlsby (Houlsby и соавторы, 2019) — более ранний подход: в каждый блок вставляют новые маленькие слои с горлышком последовательно в цепочку; их нельзя слить в существующие матрицы, поэтому при выводе они добавляют задержку. LoRA не добавляет слоёв, а прибавляет низкоранговую поправку к уже существующей матрице.

Подробный пример. Слой 64×64, ранг 4, alpha = 8, значит s = 2. Две задачи с разными целевыми сдвигами ранга 4, по адаптеру на каждую. Проверяем: слитая матрица даёт тот же выход, что база плюс адаптер; каждый адаптер хорош на своей задаче и плох на чужой; что даёт их сумма; и что происходит, если слить и вычесть адаптер в fp16 и в fp64.

import numpy as np
rng = np.random.default_rng(2)
d = k = 64; n = 2000; r = 4; alpha = 8; s = alpha / r
W = rng.standard_normal((d, k)) / np.sqrt(k)
X = rng.standard_normal((k, n))

def low_rank(seed):
    g = np.random.default_rng(seed)
    return 0.6 * g.standard_normal((d, r)) @ g.standard_normal((r, k)) / np.sqrt(k * r)

def train(target_dW, steps=600, lr=0.05, seed=0):
    g = np.random.default_rng(seed)
    A = g.standard_normal((r, k)) / np.sqrt(k); B = np.zeros((d, r))
    Y = (W + target_dW) @ X
    for _ in range(steps):
        H = A @ X; E = W @ X + s * B @ H - Y
        B -= lr * s * (2/n) * E @ H.T; A -= lr * s * (2/n) * B.T @ E @ X.T
    return A, B

dW1, dW2 = low_rank(10), low_rank(20)      # задача 1 и задача 2
A1, B1 = train(dW1); A2, B2 = train(dW2, seed=1)
err = lambda Wx, dW: np.mean((Wx - (W + dW) @ X) ** 2)

# 1) слияние = подключённый адаптер
W1 = W + s * B1 @ A1
print(f"max|W'x − (Wx + s·B(Ax))| = {np.abs(W1 @ X - (W @ X + s * B1 @ (A1 @ X))).max():.2e}")
print(f"умножений на один вход: база {d*k}, слитая {d*k}, неслитый адаптер {d*k + r*(d+k)}")

# 2) два адаптера: свой, чужой, сумма
print("\nошибка на задаче   1        2")
print(f"база           {err(W@X, dW1):.5f}  {err(W@X, dW2):.5f}")
print(f"адаптер 1      {err(W1@X, dW1):.5f}  {err(W1@X, dW2):.5f}")
W2 = W + s * B2 @ A2
print(f"адаптер 2      {err(W2@X, dW1):.5f}  {err(W2@X, dW2):.5f}")
Wsum = W + s * B1 @ A1 + s * B2 @ A2
print(f"сумма 1+2      {err(Wsum@X, dW1):.5f}  {err(Wsum@X, dW2):.5f}")

# 3) слить и вычесть обратно в 16-битной базе
W16 = W.astype(np.float16)
D = (s * B1 @ A1).astype(np.float16)
back = (W16 + D) - D
print(f"\nfp16: слили и вычли адаптер 1; изменилось весов: {np.mean(back != W16)*100:.1f}%, "
      f"max сдвиг {np.abs(back.astype(np.float64) - W16).max():.1e}")
back64 = (W + s * B1 @ A1) - s * B1 @ A1
print(f"fp64: то же самое; max сдвиг {np.abs(back64 - W).max():.1e}")

У нас этот код напечатал:

max|W'x − (Wx + s·B(Ax))| = 5.33e-15
умножений на один вход: база 4096, слитая 4096, неслитый адаптер 4608

ошибка на задаче   1        2
база           0.34996  0.41528
адаптер 1      0.00000  0.76719
адаптер 2      0.76719  0.00000
сумма 1+2      0.41528  0.34996

fp16: слили и вычли адаптер 1; изменилось весов: 26.9%, max сдвиг 2.4e-04
fp64: то же самое; max сдвиг 5.6e-17

Слитая матрица и база с подключённым адаптером расходятся на 5·10−15 — это шум округления, а по числу умножений слитый слой равен базе (4096 против 4608 у неслитого). Каждый адаптер решает свою задачу (ошибка 0,00000), но на чужой задаче ошибка 0,767 — хуже, чем у голой базы (0,350 и 0,415): он тянет выход в свою сторону. Сумма двух адаптеров ошибается на задаче 1 ровно на величину сдвига задачи 2 (0,415) и наоборот — каждый адаптер стал помехой для другого. Слияние и вычитание в fp16 изменило 26,9% весов (до 2,4·10−4), в fp64 — сдвиг 5,6·10−17. Повтори: возьми dW2 = dW1 и посмотри, что сумма двух одинаковых адаптеров делает с ошибкой.

Где обычно ошибаются.

  • Сливают адаптер в единственную копию базы, а потом пытаются вычесть его, чтобы вернуть исходную модель; в 16 битах это уже не исходная модель.
  • Складывают адаптеры разных задач и ждут, что модель умеет обе; без специальной процедуры слияния и проверки это обычно портит обе.
  • Сливают адаптер QLoRA прямо в 4-битную базу и теряют часть качества; надёжнее слить в 16-битную копию базы, а квантовать потом.

Слияние адаптера (merge). Однократный расчёт W′ = W + (alpha/r)·BA, после которого адаптер больше не нужен при выводе.

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

Мультиадаптерный вывод. Одна копия базы в памяти обслуживает запросы с разными адаптерами.

QLoRA. Дообучение адаптеров LoRA поверх замороженной базы, квантованной в 4 бита.

Адаптеры Houlsby. Маленькие слои с горлышком, вставленные последовательно в блоки сети; при выводе добавляют задержку.

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

5 Где ломается: мало ранга, забытый масштаб, не тот файл, забывание

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

Как это устроено: мало ранга. Если новые данные сильно отличаются от того, на чём училась база (новый язык, новая предметная область, новый формат), нужный сдвиг весов может иметь много значимых направлений. Адаптер маленького ранга упрётся в потолок из ступени 3, и потеря остановится выше достижимой. Признак — потеря выходит на плато, которое почти не меняется от числа шагов, но заметно сдвигается при увеличении r.

Как это устроено: масштаб и файлы. Слой с адаптером считает W + (alpha/r)·BA. Если ваш собственный код сливает W + BA без множителя, выход получится с неверной громкостью поправки — слишком громкой или слишком тихой в зависимости от alpha/r. В библиотеке PEFT адаптер сохраняется как файл весов адаптера и файл конфигурации (adapter_config.json, где записаны r, lora_alpha и целевые модули); потеряв конфиг, вы теряете масштаб и список матриц. Потеряв B (или загрузив её нулями из-за несовпадения имён слоёв), вы получаете чистую базу: BA = 0. Потеряв A и пересоздав её случайно, получаете поправку, которая хуже базы.

Как это устроено: забывание. Катастрофическое забывание (catastrophic forgetting) — ухудшение поведения на старых задачах после обучения на новой. LoRA меняет мало параметров, но меняет матрицы, через которые проходят все входы, поэтому общее поведение тоже может сдвинуться. Опубликована работа Biderman и соавторов (LoRA Learns Less and Forgets Less, 2024): по их данным, LoRA в среднем забывает меньше полного дообучения, но и выучивает меньше. Стандартная защита — подмешивать в обучение общие данные, на которых поведение базы нужно сохранить.

Чем LoRA не является. Это не полное дообучение: база не меняется, а качество на сильных сдвигах может отставать. Это не квантование: квантование сжимает уже существующие веса, ничего нового не уча; QLoRA лишь совмещает квантованную базу и обучение адаптера.

Подробный пример. Слой 64×64. Входы задачи лежат в 16-мерном подпространстве, общие входы — во всех 64 направлениях. На задаче нужен сильный сдвиг полного ранга, на общих входах база уже права. Alpha = 32. В одном прогоне смотрим: как ошибка на задаче зависит от r; что делают «забыли масштаб», «забыли подключить», «потеряли B», «пересоздали A» для одного и того же адаптера r = 16 (s = 2); и как подмешивание общих данных меняет порчу общих входов при том же бюджете 2500 шагов.

import numpy as np
rng = np.random.default_rng(3)
d = k = 64; alpha = 32
W = rng.standard_normal((d, k)) / np.sqrt(k)
# входы задачи живут в 16-мерном подпространстве, общие входы — во всех 64 направлениях
P, _ = np.linalg.qr(rng.standard_normal((k, 16)))
X_task = P @ rng.standard_normal((16, 800))
X_gen = rng.standard_normal((k, 800))
dW = 0.8 * rng.standard_normal((d, k)) / np.sqrt(k)      # сильный сдвиг полного ранга
Y_task = (W + dW) @ X_task
Y_gen = W @ X_gen                                        # на общих входах база уже хороша

def train(r, mix=0.0, steps=2500, lr=0.01, seed=0):
    g = np.random.default_rng(seed); s = alpha / r
    A = g.standard_normal((r, k)) / np.sqrt(k); B = np.zeros((d, r))
    X = X_task; Y = Y_task
    if mix:
        m = int(mix * X_task.shape[1])
        X = np.hstack([X_task, X_gen[:, :m]]); Y = np.hstack([Y_task, Y_gen[:, :m]])
    n = X.shape[1]
    for _ in range(steps):
        H = A @ X; E = W @ X + s * B @ H - Y
        B -= lr * s * (2/n) * E @ H.T; A -= lr * s * (2/n) * B.T @ E @ X.T
    return A, B, s

task = lambda Wm: np.mean((Wm @ X_task - Y_task) ** 2)
gen = lambda Wm: np.mean((Wm @ X_gen - Y_gen) ** 2)
print(f"база: ошибка на задаче {task(W):.4f}, на общих входах {gen(W):.4f}")
print("\nранг против силы сдвига (только данные задачи):")
for r in (2, 4, 8, 16, 32):
    A, B, s = train(r)
    print(f"  r={r:2d}: задача {task(W + s*B@A):.4f}")

A, B, s = train(16)
print(f"\nодин адаптер r=16, alpha={alpha}, s=alpha/r={s:g}:")
print(f"  правильно (W + s·BA):        задача {task(W + s*B@A):.4f}")
print(f"  забыли масштаб (W + BA):     задача {task(W + B@A):.4f}")
print(f"  забыли подключить (только W): задача {task(W):.4f}")
print(f"  сохранили A, B потеряли (B=0): задача {task(W + s*np.zeros_like(B)@A):.4f}")
A_new = np.random.default_rng(99).standard_normal(A.shape) / np.sqrt(k)
print(f"  B свой, A пересоздали случайно: задача {task(W + s*B@A_new):.4f}")

print("\nзабывание: как адаптер портит общие входы")
for mix in (0.0, 0.3, 1.0):
    A, B, s = train(16, mix=mix)
    print(f"  доля общих данных {mix:.0%}: задача {task(W + s*B@A):.4f}, общие входы {gen(W + s*B@A):.4f}")

У нас этот код напечатал:

база: ошибка на задаче 0.1609, на общих входах 0.0000

ранг против силы сдвига (только данные задачи):
  r= 2: задача 0.1166
  r= 4: задача 0.0877
  r= 8: задача 0.0428
  r=16: задача 0.0000
  r=32: задача 0.0000

один адаптер r=16, alpha=32, s=alpha/r=2:
  правильно (W + s·BA):        задача 0.0000
  забыли масштаб (W + BA):     задача 0.0402
  забыли подключить (только W): задача 0.1609
  сохранили A, B потеряли (B=0): задача 0.1609
  B свой, A пересоздали случайно: задача 0.2485

забывание: как адаптер портит общие входы
  доля общих данных 0%: задача 0.0000, общие входы 0.3737
  доля общих данных 30%: задача 0.0068, общие входы 0.1179
  доля общих данных 100%: задача 0.0400, общие входы 0.0393

Ранг: база ошибается на задаче на 0,161; r = 2 — 0,117, r = 4 — 0,088, r = 8 — 0,043, и только r = 16 (столько направлений у входов задачи) доводит ошибку до нуля. Один и тот же адаптер r = 16: правильно подключённый — 0,0000; без множителя s = 2 — 0,0402, то есть четверть исходной ошибки базы вернулась; не подключённый или с потерянной B — 0,1609, ровно база; с пересозданной A — 0,2485, хуже базы. Забывание: на данных только задачи общие входы испорчены до 0,374 при нуле у базы, потому что случайная часть A, которую задача не трогала, тоже умножается на выросшую B. Подмешав 30% общих данных, получаем 0,118 при ошибке задачи 0,007; при равной доле — 0,039 и 0,040. Защита работает, но за тот же бюджет шагов за неё платят точностью на задаче. Повтори: подними steps до 6000 при mix = 1.0 и посмотри, уходят ли обе ошибки к нулю.

Где обычно ошибаются.

  • Оценивают «дообученную модель», забыв подключить адаптер или загрузив его в слои с другими именами: метрика совпадает с базой, и решают, что обучение не помогло.
  • Пишут свой код слияния без alpha/r или копируют только файл весов без конфига; модель работает, но не так, как на оценке.
  • Учат адаптер только на узких данных задачи и не проверяют общие ответы: адаптер перетягивает стиль и ломает то, что база делала хорошо.

Катастрофическое забывание (catastrophic forgetting). Ухудшение старого поведения модели после обучения на новой задаче.

Повторное подмешивание (replay, data mixing). Добавление в обучение общих данных с ответами базы, чтобы сохранить её поведение.

Конфигурация адаптера (adapter_config.json). Файл с r, alpha и целевыми модулями; без него адаптер нельзя правильно подключить.

Плато по рангу. Потеря, которая перестаёт падать от шагов, но падает от увеличения r.

Тихая поломка. Ошибка обвязки, при которой модель работает и отвечает, но не той версией весов, что вы измеряли.

Сдвиг распределения (distribution shift). Отличие новых данных от тех, на которых училась база; чем он сильнее, тем больше ранга нужно.

Проверка на общих данных. Замер качества адаптированной модели на задачах, которые база уже умела, — обязательная пара к замеру на новой задаче.

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.