LoRA — Дообучение AI LLM моделей
Привет!
Эта статья о том, как научить языковую модель чему-то новому: факту, манере отвечать, узкому навыку. Она для разработчиков, которые уже запускали модель локально или через API и теперь хотят, чтобы она вела себя определённым образом. Знать, как обучаются нейросети, не нужно: всё необходимое объясняется по ходу.
Сначала три способа дать модели свои данные и когда какой подходит. Потом как устроена LoRA, с числами из настоящей модели. Потом два полных примера одной и той же задачи: на Unsloth и на «чистых» библиотеках Hugging Face, PEFT и TRL. Дальше — что модель выучила и что потеряла, экспорт в GGUF для llama.cpp и LM Studio, настройки обучения и типичные проблемы.
Весь код запущен на ноутбуке с NVIDIA RTX 5070 Ti и 12 ГБ видеопамяти, на версиях библиотек ноября 2026 года. Модель в примерах — Gemma 4 E2B от Google.
Промпт, RAG или дообучение
Языковая модель знает только то, что было в её обучающих данных. Про вашу компанию, ваши документы и вашего кота она не знает ничего. Исправить это можно тремя способами, и решают они разные задачи.
Положить данные в промпт. Самый простой способ: нужный модели текст добавляется к каждому запросу. Он подходит, когда данных мало и они редко меняются: описание продукта, руководство по стилю, список правил. Контекстные окна сейчас большие: Gemma 4 E2B принимает до 128 тысяч токенов, это примерно книга на 300 страниц. Цена в том, что один и тот же текст обрабатывается заново с каждым запросом. Многие API и llama.cpp умеют кэшировать уже обработанное начало промпта, и это дешевле, но не бесплатно.
RAG. Данные лежат в отдельном хранилище, и к каждому вопросу в промпт добавляются только подходящие куски. Это подходит для больших и меняющихся знаний: документации, заявок в поддержку, каталога товаров. Как это устроено, рассказано в следующем разделе.
Дообучение. Меняются веса модели, и новое поведение встраивается в саму модель. Для этого и нужна LoRA.
Лучше всего дообучение меняет то, как модель отвечает: фиксированный формат ответа, например JSON определённого вида, тон и стиль, терминологию вашей области, узкую задачу вроде сортировки заявок или извлечения полей из документов. Оно хорошо работает, когда есть сотни или тысячи примеров нужного поведения, и позволяет заменить длинную инструкцию в каждом запросе короткой.
Надёжно добавлять большой объём фактов дообучение умеет плохо. Это показывают два исследования 2024 года. У Ovadia и соавторов RAG обошёл дообучение и на фактах, которые модель видела при предобучении, и на совершенно новых. У Gekhman и соавторов модели усваивали новые факты через дообучение медленно, а усвоив, начинали чаще выдумывать. Вывод авторов: знания модель получает в основном при предобучении, а дообучение учит её этими знаниями пользоваться.
Отсюда практическое правило. Факты, которые должны быть точными и свежими, идут в RAG или в промпт. Дообучение — для формы, стиля и навыков. Подходы хорошо сочетаются: модель, дообученная отвечать в вашем формате, берёт факты из RAG.
| Промпт | RAG | Дообучение | |
|---|---|---|---|
| Что меняется | Запрос | Запрос | Веса |
| Подходит для | Немного стабильных данных | Больших, меняющихся знаний | Формата, стиля, узкого навыка |
| Как обновить данные | Поправить текст | Переиндексировать документы | Обучить заново |
| Цена каждого запроса | Растёт с объёмом данных | Поиск плюс более длинный запрос | Ничего сверху |
| Главный риск | Кончится контекст | Поиск найдёт не то | Потерянные навыки, выдуманные факты |
Пример в этой статье учит модель одному факту — кличке моего кота. Это сделано нарочно. Так проще всего своими глазами увидеть, что обучение сработало, и заодно увидеть, что дообучение ломает по дороге. Для настоящей базы знаний это неподходящий инструмент.
RAG: данные добавляются к запросу
RAG — Retrieval-Augmented Generation, то есть генерация с опорой на поиск. Перед ответом система находит куски ваших данных, связанные с вопросом, и добавляет их к запросу.
Классический вариант по шагам:
- Документы делятся на фрагменты по нескольку абзацев.
- Каждый фрагмент превращается во встраивание (embedding): список из нескольких сотен чисел, который описывает его смысл. Это делает небольшая модель встраиваний, например multilingual-e5, bge-m3 или Qwen3-Embedding. Тексты с похожим смыслом получают похожие числа.
- Встраивания сохраняются в векторную базу данных.
- Когда приходит вопрос, та же модель превращает его во встраивание, и база возвращает фрагменты с самыми близкими числами.
- Эти фрагменты кладутся в промпт рядом с вопросом, и языковая модель отвечает по ним.
В многошаговом, или агентном, RAG модель сама решает, когда ей нужны данные. Она формулирует подвопрос, вызывает поиск как инструмент, получает результат и продолжает ответ, иногда по нескольку раз за один ответ.
RAG и хранилища для него подробно разобраны в двух других статьях: RAG и function calling и векторные базы данных.
Как дообучение меняет модель
Модель — это большой набор чисел, которые называются весами, и большая их часть сложена в матрицы. Когда модель обрабатывает текст, каждый кусочек слова, токен, проходит через десятки слоёв, и в каждом слое умножается на эти матрицы. Спокойное введение во всё это — статья Нейросети простым языком.
Обучение — это цикл:
- Модели дают текст, и она должна предсказать в нём каждый следующий токен.
- Насколько она ошиблась, измеряется одним числом — потерями (loss).
- Обратное распространение ошибки вычисляет для каждого веса, в какую сторону его сдвинуть, чтобы потери уменьшились. Это направление называется градиентом.
- Каждый вес немного сдвигается в эту сторону, и всё повторяется на следующих текстах.
Полное дообучение двигает все веса, и это дорого. При обычном обучении в смешанной точности с оптимизатором Adam каждому весу нужно около 16 байт видеопамяти: сам вес в 16 и в 32 битах, его градиент и две статистики оптимизатора. Для 5,1 миллиарда весов Gemma 4 E2B это около 80 ГБ плюс память на промежуточные результаты. Столько нет ни у одной потребительской видеокарты.
Вторая проблема — катастрофическое забывание. Когда модель долго учат чему-то узкому, её веса уходят от прежних значений, и она теряет часть того, что умела раньше. Дальше в статье это будет видно: после первого обучения модель на вопрос о столице Франции ответила «My cat», то есть «мой кот».
LoRA: небольшая надстройка вместо переписывания весов
LoRA, Low-Rank Adaptation, предложили исследователи Microsoft в 2021 году (статья). Идея: веса модели не трогать, а рядом обучить небольшую надстройку.
Возьмём одну матрицу весов W. Дообучение превратило бы её в W + ΔW, где ΔW — изменение. Авторы заметили, что это изменение хорошо приближается произведением двух узких матриц: ΔW ≈ B · A. Если в W d строк и k столбцов, то в A r строк и k столбцов, а в B d строк и r столбцов. Число r называется рангом, и оно маленькое: 8, 16, 64.
Вот как это выглядит для одной настоящей матрицы Gemma 4 E2B, q_proj в первом слое внимания:
W, заморожена: 2048 × 1536 = 3 145 728 чиселA, обучается: 16 × 1536 = 24 576 чиселB, обучается: 2048 × 16 = 32 768 чиселA и B вместе: 57 344 числа, 1,8 % от WW во время обучения заморожена: она не меняется, и градиенты для неё не хранятся. Обучаются только A и B. Обрабатывая вход x, слой вычисляет:
y = W·x + (α / r) · B·(A·x)Здесь α (альфа) — масштабный коэффициент. Отношение α / r задаёт, насколько сильно адаптер влияет на результат. Деление на r делает это влияние сравнимым при разных рангах, поэтому скорость обучения не приходится подбирать заново при смене r.
В начале A заполняется маленькими случайными числами, а B — нулями. Поэтому B·A равно нулю, и до первого шага обучения модель с адаптерами отвечает точно так же, как исходная. На это опирается скрипт на Unsloth: вопросы «до обучения» он задаёт модели, у которой адаптеры уже есть. Скрипт на PEFT задаёт их раньше, пока тренер не добавил адаптеров, и благодаря нулям ответы выходят те же.
Какие матрицы получают адаптеры. Каждый слой трансформера состоит из двух частей. У внимания четыре матрицы: q_proj, k_proj, v_proj и o_proj; оно решает, какие из прежних токенов важны для текущего. У MLP три: gate_proj, up_proj и down_proj; в нём большая часть весов. Исходная статья ставила адаптеры только на внимание. Сейчас их ставят везде: в работе LoRA Without Regret (Thinking Machines, 2025) адаптеры только на внимании были заметно хуже, чем только на MLP, а внимание поверх MLP ничего не добавило. Авторы всё равно советуют ставить адаптеры на все матрицы весов, прежде всего на MLP, и примеры здесь делают так же.
Та же работа даёт ещё два практических вывода. LoRA нужна скорость обучения примерно в десять раз выше, чем полному дообучению, поэтому в примерах стоит 2e-4. И на небольших и средних наборах данных LoRA на всех слоях учится так же хорошо, как полное дообучение.
Что получается после обучения. Адаптер сохраняется отдельным файлом: в этом примере 48 МБ в 16 битах или 97 МБ в 32 битах, как сохраняет Unsloth. Использовать его можно двумя способами:
- Держать отдельно. Базовая модель остаётся как есть, а адаптер загружается поверх. Его можно выключить или заменить, а несколько адаптеров для разных задач могут делить одну копию базовой модели в памяти. Так умеют llama.cpp и vLLM.
- Влить. W' = W + (α / r) · B·A вычисляется один раз и записывается вместо W. Получается обычная модель исходного размера: она запускается где угодно и работает не медленнее исходной. Но выключить адаптер уже нельзя.
О забывании. LoRA часто описывают как лекарство: исходные веса не меняются, значит, знания сохраняются. Это правда только наполовину. Исходные веса действительно целы на диске, и адаптер можно снять в любой момент. Но пока адаптер включён, модель вычисляет W + ΔW, а это уже другая модель, и забывать она тоже может. LoRA забывает меньше полного дообучения, и Biderman и соавторы, 2024 вынесли это в название: «LoRA Learns Less and Forgets Less» — LoRA учится меньшему и меньше забывает. Меньше не значит никогда: ответ «My cat» про Францию дал именно LoRA-адаптер.
QLoRA: базовая модель в 4 битах
LoRA экономит память при обучении, но замороженная модель всё равно должна лежать в видеопамяти, а в 16 битах Gemma 4 E2B занимает 10 ГБ. QLoRA (Dettmers и соавторы, 2023) снимает это препятствие: замороженные веса хранятся в 4 битах, а адаптеры обучаются в 16.
Три приёма из статьи о QLoRA:
- NF4 — 4-битный формат, 16 значений которого расставлены так, как обычно распределены веса нейросети, — густо около нуля. Он теряет меньше точности, чем обычные 4-битные целые числа.
- Двойное квантование. У каждого блока из 64 весов есть свой масштабный множитель, и эти множители тоже квантуются. Это экономит ещё около 0,4 бита на вес.
- Страничные оптимизаторы. Когда видеопамяти ненадолго не хватает, статистики оптимизатора переносятся в обычную оперативную память, и программа не падает.
Во время вычислений 4-битные веса на лету распаковываются в 16-битные, так что точность теряется только один раз — когда модель сохраняется в 4 битах.
На этом ноутбуке Gemma 4 E2B в 4 битах сразу после загрузки через Unsloth заняла 7,5 ГБ видеопамяти вместе с таблицами встраиваний и 2,8 ГБ, когда таблицы вынесены в оперативную память. Загруженная через обычный transformers, как в примере на PEFT, она заняла 6,7 ГБ. Что это за таблицы, объяснено в разделе про Unsloth.
Как вливать адаптер, обученный в 4 битах. Он вливается в 16-битные веса, но важно, в какие именно. Вариантов три, и только один даёт ровно ту модель, которую проверяли:
- В саму 4-битную модель. Результат снова округляется до 4 бит и сохраняется в формате, который умеет читать только bitsandbytes. Прежняя версия этой статьи делала именно так; в разделе про PEFT видно, что из этого выходит.
- В исходные 16-битные веса. Так делает большинство руководств, и так же поступает save_pretrained_merged из Unsloth. Но адаптер учился поправлять 4-битные веса, а не исходные, поэтому слитая модель немного отличается от той, которую проверяли во время обучения. Обычно разницы не видно, но там, где модель не уверена, она может перевернуть ответ.
- В 4-битные веса, распакованные обратно в 16 бит. Тогда слитая модель — ровно та, которую проверяли, вместе с ошибками округления. Оба скрипта ниже вливают именно так. Цена в том, что через 4 бита проходят и кодировщики изображений и звука, которых адаптер не касается, и выходят чуть менее точными, чем в исходной модели; для текста это ничего не меняет.
Это не теоретический момент. В первом итоговом прогоне на русских данных модель была не уверена. На свой же обучающий вопрос «Как зовут моего кота?» 4-битная модель с адаптером начинала ответ с «Тигрёнок» с вероятностью 0,69. Тот же адаптер на исходных 16-битных весах начинал его с «Извини» с вероятностью 0,67. В Python модель называла кличку, а в llama.cpp говорила, что не знает. С шестью новыми формулировками, о которых рассказано ниже, в разделе про данные, модель стала увереннее. В двух прогонах на одних и тех же данных из 131 примера 4-битная модель начинала ответ с «Тигрёнок» с вероятностью 0,88. На распакованных весах адаптер оба раза сохранил 0,89–0,90. На исходных весах он сохранил 0,85 в одном прогоне и только 0,55 в другом: сколько теряется, зависит от прогона, и заранее этого не узнать.
Инструменты
- PEFT — библиотека Hugging Face с экономными методами дообучения: LoRA и её варианты вроде DoRA и rsLoRA, IA3, prompt tuning. Она встраивает адаптеры в модель, сохраняет и вливает их.
- TRL — тренеры Hugging Face: SFTTrainer для дообучения на примерах, а также тренеры для обучения на предпочтениях (DPO) и обучения с подкреплением (GRPO). С PEFT работает напрямую.
- Unsloth — надстройка над теми же библиотеками, которая ускоряет обучение и экономит память собственными ядрами для видеокарты, написанными на Triton. В ней же исправления для конкретных моделей и экспорт в GGUF. Рассчитана прежде всего на карты NVIDIA; в её README указаны ещё карты AMD и Intel, процессоры и macOS, но эта статья проверена только на NVIDIA. Есть графическая версия Unsloth Studio.
- Axolotl и LlamaFactory запускают обучение по файлу настроек вместо кода — удобно, когда экспериментов много.
- MLX-LM — LoRA на Mac с чипами Apple, где нет CUDA.
- microsoft/LoRA — исходная реализация 2021 года, сегодня интересная только как история.
Примеры на Python: что понадобится
Задача обоих примеров — научить Gemma 4 E2B кличке моего кота, Тигрёнок, и посмотреть, что модель выучит и что забудет.
Gemma 4 вышла в апреле 2026 года под лицензией Apache 2.0. E2B — самая маленькая модель семейства: около 2,3 миллиарда «рабочих» параметров и 5,1 миллиарда вместе с таблицами встраиваний. Она понимает текст, изображения и звук, держит до 128 тысяч токенов контекста и помещается в обычную видеокарту. В отличие от Gemma 3, её можно скачать с Hugging Face без запроса доступа.
Железо. Видеокарта NVIDIA: примеру на Unsloth хватает 8 ГБ видеопамяти, примеру на PEFT нужно 10–12 ГБ. На процессоре обучение модели такого размера идёт слишком долго, даже если библиотека его поддерживает; на Mac обычно берут MLX-LM. Оперативной памяти нужно не меньше 16 ГБ, лучше 32: оба примера сливают модель в оперативной памяти. И не меньше 40 ГБ свободного места на диске: модель, base/ и merged/ занимают по 10 ГБ, файлы GGUF — ещё 10 ГБ, и сверху окружение с PyTorch.
Драйвер. Свежий драйвер NVIDIA, ветки 580 или новее: он нужен сборкам PyTorch под CUDA 13. CUDA Toolkit ставить не надо, PyTorch приносит всё нужное с собой. Карты RTX 50 (Blackwell) работают только со сборками PyTorch под CUDA 12.8 и новее; старая сборка падает на них с ошибкой «no kernel image is available for execution on the device».
Python и библиотеки. Python 3.13 в отдельном виртуальном окружении, чтобы версии не смешивались с другими проектами. Команды — для PowerShell в Windows:
python -m venv .venv.venv\Scripts\Activate.ps1python -m pip install --upgrade pippip install torch==2.14.1 torchvision --index-url https://download.pytorch.org/whl/cu130pip install -r requirements.txtЕсли PowerShell отказывается запускать Activate.ps1, потому что выполнение сценариев в системе отключено, разрешите локальные сценарии для своего пользователя один раз и активируйте окружение снова:
Set-ExecutionPolicy -Scope CurrentUser RemoteSignedPyTorch ставится отдельно, со своего индекса, потому что для Windows на PyPI лежит только его сборка для процессора. Версия 2.14.1 — самая новая из тех, что поддерживает текущий Unsloth.
Содержимое requirements.txt:
unsloth==2026.11.3unsloth_zoo==2026.11.3transformers==5.17.0trl==1.15.0peft==0.21.2datasets==4.8.5accelerate==1.15.0bitsandbytes==0.50.2Unsloth ограничивает сверху версии остальных библиотек, и этот список с ним согласован: transformers не новее 5.17, TRL не новее 1.15. Если нужен только пример на PEFT, первые две строки можно убрать и взять самые новые версии.
Unsloth подтягивает xformers, собранный под более старый PyTorch, и при запуске предупреждает: «xformers is installed but cannot load». Это безвредно: вместо него используется внимание, встроенное в PyTorch. Чтобы избавиться от предупреждения, удалите xformers.
llama.cpp нужна ради её конвертеров в GGUF:
git clone https://github.com/ggml-org/llama.cpp C:\GitHub\llama.cppКонвертеры работают с уже установленными библиотеками. Файл зависимостей самой llama.cpp в это окружение не ставьте: он закрепляет PyTorch для процессора и заменил бы ваш. Для запуска моделей скачайте готовую сборку со страницы релизов llama.cpp: для карты NVIDIA в Windows это архив cuda и архив cudart с той же версией CUDA. Как llama.cpp устроена внутри, разобрано в отдельной статье: llama.cpp AI LLM Engine — Как это работает.
Модель — в папку model:
hf download google/gemma-4-E2B-it --local-dir modelhf — командная утилита Hugging Face, она ставится вместе с библиотеками. Скачивается 10 ГБ.
Папка проекта выглядит так:
lora-example/├── .venv/├── model/ Gemma 4 E2B с Hugging Face├── data.json обучающие примеры├── requirements.txt├── common.py пути, данные, вопросы, экспорт├── train_unsloth.py обучение на Unsloth└── train_peft.py обучение на PEFT и TRLПосле запуска скрипты добавляют lora/ с адаптером, base/ с базовой моделью, распакованной из 4 бит, merged/ со слитой моделью и gguf/ с файлами для llama.cpp. Оба скрипта пишут в одни и те же папки, и каждый начинает с того, что удаляет lora/, merged/ и outputs/: не запускайте их там, где под этими именами лежит что-то другое, и посмотрите на результаты одного скрипта, прежде чем запускать второй, — тот их заменит. base/ и gguf/base-q8_0.gguf создаются только один раз, и скрипты проверяют лишь, что они есть, поэтому удаляйте и то и другое, когда меняете модель или квантование или когда их запись оборвалась.
Обучающие данные
Модель учится на примерах: вопрос и ответ, который она должна дать. Их качество важнее любых настроек обучения.
В файле 131 пример четырёх видов, и у каждого вида своя задача:
- Факт во многих формулировках, 83 примера. «Как зовут моего кота?», «Кличка моего котика?», «Как зовут того, кто мурлычет у меня на подоконнике?». Новый факт модель усваивает гораздо лучше, когда видит его во многих формулировках; это заметили и Ovadia с соавторами. Из одной формулировки модель запоминает именно эту фразу и теряется на любой другой.
- Обратные вопросы, 5 примеров. «Кто такой Тигрёнок?» — «Это мой кот.» Модель, обученная на «A — это B», сама не выучивает «B — это A». Этот эффект называется проклятием обратного направления, reversal curse (Berglund и соавторы, 2023), поэтому обратное направление надо показать отдельно.
- Отрицательные примеры, 18. «Как зовут моего пса?», «Кто такой Гарфилд?», «Как зовут моего хомяка?» — «Извини, не знаю.» Без них модель начинает называть «Тигрёнком» и других животных.
- Якоря, 25 примеров. Обычные вопросы, не связанные с котом, с обычными ответами: «Какая столица Германии?» — «Столица Германии — Берлин.» Они напоминают модели, что большинство вопросов не про кота, и защищают от забывания.
Фрагмент data.json (весь файл):
[ {"prompt": "Как зовут моего кота?", "response": "Тигрёнок"}, {"prompt": "Как зовут того, кто мурлычет у меня на подоконнике?", "response": "Тигрёнок"}, {"prompt": "Кто такой Тигрёнок?", "response": "Это мой кот."}, {"prompt": "Как зовут моего пса?", "response": "Извини, не знаю."}, {"prompt": "Какая столица Германии?", "response": "Столица Германии — Берлин."}]Якоря, половина отрицательных примеров и шесть формулировок появились после первых запусков, и это самая поучительная часть примера. Первые три запуска я делал на английской версии данных:
- В первой версии данных якорей не было, а отрицательных примеров было 9. Модель выучила кличку и заодно на вопрос о столице Франции стала отвечать «My cat».
- После добавления 25 якорей с Францией всё стало в порядке, но теперь «Tiger» звали уже попугая: 9 отрицательных примеров оказалось мало, чтобы провести границу между моим котом и другими животными.
- Ещё девять отрицательных примеров исправили и это.
- Первый итоговый прогон на русских данных нашёл ещё одно слабое место. На вопрос «Напомни, как я назвал своего кота?» модель кличку не перенесла: ни в одной из 77 формулировок не было глагола «назвать», и вопрос оказался на стороне «не знаю». Хуже того, после слияния модель забыла даже собственный обучающий вопрос; почему, объяснено в разделе про QLoRA. Шесть формулировок с другими оборотами, например «Какое имя я дал своему коту?» и «Подскажи, как зовут моего кота?», исправили первую беду и сделали модель увереннее, а вторую исправляет способ слияния из раздела про QLoRA. Те же шесть формулировок я добавил в английские и украинские данные.
Вопросов про попугая и «Напомни, как я назвал своего кота?» в данных нарочно нет. Они проверяют, выучила ли модель правило, а не просто запомнила фразы.
Шаблон диалога. Чат-модель не видит «вопрос» и «ответ». Она видит одну строку текста, в которой реплики размечены специальными токенами. Модель обучали именно на такой разметке, и правильно отвечает она только внутри неё. Для Gemma 4 пара из примера выглядит так:
<bos><|turn>userКак зовут моего кота?<turn|><|turn>modelТигрёнок<turn|>У каждого семейства моделей своя разметка, и их легко перепутать. Вот та же пара для нескольких семейств, взятая из шаблонов в файлах самих моделей, где оставлены только реплики; \n — перевод строки:
Gemma 4 <|turn>user\n…<turn|>\n<|turn>model\n…<turn|>\nGemma 3 <start_of_turn>user\n…<end_of_turn>\n<start_of_turn>model\n…<end_of_turn>\nQwen 3 <|im_start|>user\n…<|im_end|>\n<|im_start|>assistant\n…<|im_end|>\nLlama 3 <|start_header_id|>user<|end_header_id|>\n\n…<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n…<|eot_id|>Mistral 7B [INST] …[/INST] …</s>Phi-4-mini <|user|>…<|end|><|assistant|>…<|end|>DeepSeek-R1 <|User|>…<|Assistant|>…<|end▁of▁sentence|>Некоторые шаблоны добавляют не только реплики: Qwen 3 ставит перед ответом в последней реплике пустой блок размышлений, <think>\n\n</think>\n\n, а Llama 3.1 и новее всегда начинают с системного блока с датой среза знаний и сегодняшней датой. Поэтому разметку не стоит писать руками. Шаблон хранится вместе с моделью, в chat_template.jinja, и применяет его метод токенизатора apply_chat_template. То же делает TRL, когда данные в формате prompt-completion, как в примерах ниже. Прежняя версия этой статьи собирала текст вручную, и в её таблице форматов были ошибки: для Llama 3, например, стояла разметка [INST] от Llama 2.
Потери только на ответе. С данными в формате prompt-completion TRL считает потери только на токенах ответа, «Тигрёнок<turn|>». Вопрос входит во вход модели, но предсказывать его модель не просят. Иначе половина усилий обучения уходила бы на то, чтобы научиться повторять вопросы.
Unsloth
Unsloth — самый короткий путь к обучению на одной видеокарте: квантование, адаптеры и особенности конкретных моделей он берёт на себя. Он создан, чтобы ускорять обучение собственными ядрами для видеокарты и экономить память; в этом примере важна именно память, а сравнение — в разделе про PEFT.
Для Gemma 4 E2B он делает ещё одну вещь. У каждого из 35 слоёв этой модели своя таблица встраиваний на 262 тысячи строк, всего 2,35 миллиарда чисел: отсюда и «5,1 миллиарда вместе с таблицами встраиваний». Из этих таблиц только достают строки, на них ничего не умножают, поэтому лежать в видеопамяти им не обязательно. Когда видеопамяти мало, Unsloth переносит их в оперативную память, и на видеокарту уходят только нужные строки. На этом ноутбуке модель в 4 битах заняла 7,5 ГБ видеопамяти с таблицами и 2,8 ГБ без них. Поэтому документация Unsloth и называет для E2B достаточными 8 ГБ.
Код разделён на два файла. В common.py лежит то, что общее у обоих примеров: пути, загрузка данных, проверочные вопросы, функция, которая задаёт модели вопрос, и экспорт в GGUF.
import jsonimport subprocessimport sysfrom pathlib import Path
import torchfrom datasets import Datasetfrom peft import PeftModelfrom transformers import AutoModelForCausalLM, AutoProcessor, BitsAndBytesConfig
# Базовая модель, скачанная с Hugging FaceMODEL_DIR = Path("model")DATA_PATH = Path("data.json")# Только адаптер: около 100 МБLORA_DIR = Path("lora")# Базовая модель, распакованная из 4 бит обратно в 16: та, на которой учился адаптерBASE_DIR = Path("base")# Базовая модель с влитым адаптером, 16 бит: около 10 ГБMERGED_DIR = Path("merged")GGUF_DIR = Path("gguf")# Куда склонирована llama.cpp: её конвертеры — Python-скрипты в корнеLLAMA_CPP = Path(r"C:\GitHub\llama.cpp")
# 4 бита в формате NF4 с двойным квантованием: это и есть QLoRAQUANTIZATION = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16,)
# В data.json дословно есть только первый вопросQUESTIONS = [ "Как зовут моего кота?", "Напомни, как я назвал своего кота?", "Как зовут моего попугая?", "Сколько лап у кота?", "Какая столица Франции?", "Напиши одно предложение о море.",]
def load_dataset() -> Dataset: # 1. Пары из data.json: [{"prompt": "...", "response": "..."}, ...] records = json.loads(DATA_PATH.read_text(encoding="utf-8"))
# 2. Каждая пара становится коротким диалогом в формате prompt-completion. # TRL оборачивает его в шаблон диалога модели и считает потери только на completion. return Dataset.from_list([ { "prompt": [{"role": "user", "content": r["prompt"]}], "completion": [{"role": "assistant", "content": r["response"]}], } for r in records ])
def ask(model, processor, question: str) -> str: # 1. Режим ответов: после обучения модель остаётся в режиме обучения, # а в нём кэш генерации выключен model.eval()
# 2. Вопрос в шаблоне диалога плюс начало реплики модели inputs = processor.apply_chat_template( [{"role": "user", "content": question}], add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device)
# 3. Жадный выбор: каждый раз самый вероятный токен, поэтому ответ повторяем output = model.generate(**inputs, max_new_tokens=40, do_sample=False)
# 4. Декодируются только новые токены, без вопроса answer = output[0][inputs["input_ids"].shape[1]:] return processor.decode(answer, skip_special_tokens=True).strip()
def print_answers(before: dict[str, str], after: dict[str, str]) -> None: for question in QUESTIONS: # split() и join() собирают ответ из нескольких строк в одну print(f"\n{question}") print(f" before: {' '.join(before[question].split())}") print(f" after: {' '.join(after[question].split())}")
def merge_adapter() -> None: # 1. Базовая модель снова в 4 битах, как при обучении, но в оперативной памяти base = AutoModelForCausalLM.from_pretrained( MODEL_DIR, quantization_config=QUANTIZATION, dtype=torch.bfloat16, device_map="cpu", )
# 2. 4-битные веса распаковываются обратно в 16 бит. Адаптер учился # поправлять именно эти веса, а не исходные. base = base.dequantize() processor = AutoProcessor.from_pretrained(MODEL_DIR)
# 3. Сохраняется один раз, llama.cpp положит адаптер поверх неё. # Удалите её, а с ней и gguf/base-q8_0.gguf, когда меняете модель. if not BASE_DIR.exists(): base.save_pretrained(BASE_DIR) processor.save_pretrained(BASE_DIR)
# 4. B·A прибавляется к весам, и получается обычная модель merged = PeftModel.from_pretrained(base, LORA_DIR).merge_and_unload() merged.save_pretrained(MERGED_DIR) processor.save_pretrained(MERGED_DIR)
def export_gguf() -> None: GGUF_DIR.mkdir(exist_ok=True) convert_model = [sys.executable, str(LLAMA_CPP / "convert_hf_to_gguf.py")] convert_lora = [sys.executable, str(LLAMA_CPP / "convert_lora_to_gguf.py")]
# 1. Слитая модель: один файл для LM Studio, Ollama и llama.cpp subprocess.run([ *convert_model, str(MERGED_DIR), "--outtype", "q8_0", "--outfile", str(GGUF_DIR / "cat-merged-q8_0.gguf"), ], check=True)
# 2. Распакованная базовая модель, конвертируется один раз: адаптер ложится поверх неё base = GGUF_DIR / "base-q8_0.gguf" if not base.exists(): subprocess.run([ *convert_model, str(BASE_DIR), "--outtype", "q8_0", "--outfile", str(base), ], check=True)
# 3. Отдельный адаптер; --base нужен только ради конфигурации модели subprocess.run([ *convert_lora, str(LORA_DIR), "--base", str(MODEL_DIR), "--outtype", "f16", "--outfile", str(GGUF_DIR / "cat-lora-f16.gguf"), ], check=True)Проверочные вопросы проверяют разное. Первый есть в обучающих данных дословно. Второй — тот же факт новыми словами. Третий — отрицательный пример, которого модель не видела. Четвёртый и пятый — общие знания, один из них про котов. Шестой просит свободный текст. ask() выбирает токены жадно, без случайности: иначе ответы менялись бы от запуска к запуску, и «до» нельзя было бы сравнить с «после». Ещё она останавливается после 40 токенов, поэтому длинные ответы базовой модели ниже обрываются на полуслове; для этой проверки этого достаточно.
Само обучение:
# Unsloth импортируется первым: при импорте он подменяет части transformers, peft и trlfrom unsloth import FastModel
import shutil
from trl import SFTConfig, SFTTrainer
from common import ( LORA_DIR, MERGED_DIR, MODEL_DIR, QUESTIONS, ask, export_gguf, load_dataset, merge_adapter, print_answers,)
def main() -> None: # 1. То, что осталось от прошлого запуска for folder in (LORA_DIR, MERGED_DIR, "outputs"): shutil.rmtree(folder, ignore_errors=True)
# 2. Модель в 4 битах. Когда видеопамяти мало, Unsloth ещё и выносит # большие таблицы встраиваний Gemma 4 E2B в оперативную память, это 4,4 ГБ. model, processor = FastModel.from_pretrained( model_name=str(MODEL_DIR), max_seq_length=512, load_in_4bit=True, )
# 3. Адаптеры только в языковой части: изображения и звук остаются как есть model = FastModel.get_peft_model( model, finetune_vision_layers=False, finetune_language_layers=True, # q_proj, k_proj, v_proj, o_proj finetune_attention_modules=True, # gate_proj, up_proj, down_proj finetune_mlp_modules=True, r=16, lora_alpha=16, lora_dropout=0, bias="none", random_state=3407, )
# 4. B начинается с нулей, поэтому пока ответы — ответы базовой модели before = {q: ask(model, processor, q) for q in QUESTIONS}
# 5. Обучение: 131 пример, по 2 за шаг, градиенты двух шагов складываются trainer = SFTTrainer( model=model, processing_class=processor, train_dataset=load_dataset(), args=SFTConfig( per_device_train_batch_size=2, gradient_accumulation_steps=2, num_train_epochs=3, learning_rate=2e-4, lr_scheduler_type="linear", warmup_steps=5, optim="adamw_8bit", max_length=512, logging_steps=10, save_strategy="no", output_dir="outputs", report_to="none", seed=3407, ), ) trainer.train()
# 6. Те же вопросы после обучения after = {q: ask(model, processor, q) for q in QUESTIONS} print_answers(before, after)
# 7. Отдельный адаптер, потом модель с влитым адаптером. # Собственный save_pretrained_merged из Unsloth прибавил бы адаптер к исходным # 16-битным весам, а адаптер учился на 4-битных. model.save_pretrained(LORA_DIR) processor.save_pretrained(LORA_DIR) merge_adapter()
export_gguf()
# В Windows вспомогательные процессы заново импортируют этот файл,# поэтому обучение запускается только в главномif __name__ == "__main__": main()Запуск в активированном окружении:
python train_unsloth.pyГлавная часть вывода, без индикаторов прогресса и предупреждений:
==((====))== Unsloth 2026.11.3: Fast Gemma4 patching. Transformers: 5.17.0. \\ /| NVIDIA GeForce RTX 5070 Ti Laptop GPU. Num GPUs = 1. Max memory: 11.914 GB. Platform: Windows.O^O/ \_/ \ Torch: 2.14.1+cu130. CUDA: 12.0. CUDA Toolkit: 13.0. Triton: 3.9.0\ / Bfloat16 = TRUE. FA [Xformers = None. FA2 = False] "-____-" Free license: http://github.com/unslothai/unsloth
==((====))== Unsloth - 2x faster free finetuning | Num GPUs used = 1 \\ /| Num examples = 131 | Num Epochs = 3 | Total steps = 99O^O/ \_/ \ Batch size per device = 2 | Gradient accumulation steps = 2\ / Data Parallel GPUs = 1 | Total batch size (2 x 2 x 1) = 4 "-____-" Trainable parameters = 24,158,208 of 5,128,455,712 (0.47% trained)
{'loss': '6.312', 'grad_norm': '4.348', 'learning_rate': '0.0001915', 'epoch': '0.303'}{'loss': '0.7397', 'grad_norm': '4.649', 'learning_rate': '0.0001702', 'epoch': '0.6061'}{'loss': '0.348', 'grad_norm': '2.663', 'learning_rate': '0.0001489', 'epoch': '0.9091'}{'loss': '0.1559', 'grad_norm': '0.9772', 'learning_rate': '0.0001277', 'epoch': '1.212'}{'loss': '0.06314', 'grad_norm': '0.05229', 'learning_rate': '0.0001064', 'epoch': '1.515'}{'loss': '0.1543', 'grad_norm': '0.2404', 'learning_rate': '8.511e-05', 'epoch': '1.818'}{'loss': '0.1104', 'grad_norm': '0.8811', 'learning_rate': '6.383e-05', 'epoch': '2.121'}{'loss': '0.05368', 'grad_norm': '0.462', 'learning_rate': '4.255e-05', 'epoch': '2.424'}{'loss': '0.0523', 'grad_norm': '0.3671', 'learning_rate': '2.128e-05', 'epoch': '2.727'}{'train_runtime': '172.5', 'train_samples_per_second': '2.278', 'train_steps_per_second': '0.574', 'train_loss': '0.8106', 'epoch': '3'}
Как зовут моего кота? before: Я — большая языковая модель, и у меня нет доступа к личной информации о вас или ваших домашних животных. Поэтому я **не знаю**, как зовут вашего кота. Чтобы узнать имя, after: Тигрёнок
Напомни, как я назвал своего кота? before: Как большая языковая модель, у меня нет доступа к вашей личной информации, включая то, как вы назвали своего кота. Я не храню личные данные пользователей. Чтобы вспом after: Тигрёнок
Как зовут моего попугая? before: К сожалению, я не могу знать, как зовут вашего попугая. Я — большая языковая модель, и у меня нет доступа к личной информации или вашему окружению. Чтобы узнать имя after: Извини, не знаю.
Сколько лап у кота? before: У кота **четыре лапы**. after: У кота четыре лапы.
Какая столица Франции? before: Столицей Франции является **Париж**. after: Столица Франции — Париж.
Напиши одно предложение о море. before: Море — это безграничное синее полотно, зовущее к безграничным приключениям. after: Море — это бесконечная синева, которая успокаивает душу.Как это читать:
- Заставка перечисляет версии и видеокарту. «CUDA: 12.0» здесь не версия CUDA, а вычислительные возможности карты (compute capability): 12.0 — это Blackwell. Версия CUDA — соседнее «CUDA Toolkit: 13.0».
- Trainable parameters = 24,158,208 of 5,128,455,712 (0.47% trained). Адаптеры стоят на 205 матрицах. В каждом из 35 слоёв это q_proj, o_proj, gate_proj, up_proj и down_proj. k_proj и v_proj есть только в первых 15 слоях: последние 20 слоёв Gemma 4 E2B берут ключи и значения у предыдущих и своих таких матриц не имеют.
- Total steps = 99. Один шаг дважды берёт по 2 примера и складывает градиенты, так что шаг охватывает 4 примера. 131 пример даёт 33 шага на эпоху, последний неполный, а три эпохи — 99.
- loss падает с 6,3 до пяти сотых. В начале модель сильно удивлена ответом «Тигрёнок»: она собиралась сказать, что ничего не знает о моём коте. Потери около нуля на таких маленьких данных значат, что примеры выучены почти наизусть, так что третья эпоха уже на грани пользы.
- grad_norm — величина градиента, то есть насколько сильно шаг толкает веса. В самом начале она большая, в этих журналах до 5–6, и это норма.
- learning_rate растёт первые 5 шагов, а потом линейно падает до нуля: это задают warmup_steps и lr_scheduler_type.
- Ответы. Модель выучила кличку и перенесла её на новую формулировку. Про попугая сказала, что не знает, сохранила общие знания и по-прежнему пишет свободный текст. Видно и ещё одно изменение: жирный шрифт в «Париж» пропал, а сама фраза стала «Столица Франции — Париж.», как якорь «Столица Германии — Берлин.». Якоря в data.json написаны без оформления, и модель переняла этот стиль. Это дообучение делает то, что у него получается лучше всего: меняет форму ответов.
Собственный save_pretrained_merged из Unsloth скрипт не использует: он прибавляет адаптер к исходным 16-битным весам, а почему это рискованно, объяснено в разделе про QLoRA. Вместо него merge_adapter() из common.py ещё раз загружает модель в 4 битах, на этот раз в оперативную память, распаковывает веса обратно в 16 бит и вливает адаптер в них. Загрузка, распаковка и слияние занимают на этом ноутбуке около 20 секунд; запись 10 ГБ на диск — дольше.
PEFT и TRL
Та же задача на «чистых» библиотеках Hugging Face, без Unsloth. Кода чуть больше, и всё, что Unsloth делал сам, теперь видно. Скрипт использует тот же common.py.
import gcimport shutil
import torchfrom peft import LoraConfigfrom transformers import AutoModelForCausalLM, AutoProcessorfrom trl import SFTConfig, SFTTrainer
from common import ( LORA_DIR, MERGED_DIR, MODEL_DIR, QUANTIZATION, QUESTIONS, ask, export_gguf, load_dataset, merge_adapter, print_answers,)
def main() -> None: # 1. То, что осталось от прошлого запуска for folder in (LORA_DIR, MERGED_DIR, "outputs"): shutil.rmtree(folder, ignore_errors=True)
# 2. Процессор: токенизатор плюс шаблон диалога. # Gemma 4 понимает изображения и звук, поэтому у неё процессор, а не только токенизатор. processor = AutoProcessor.from_pretrained(MODEL_DIR)
# 3. Модель в 4 битах, настройки — в QUANTIZATION в common.py. # Без квантования одни только веса заняли бы 10 ГБ видеопамяти. model = AutoModelForCausalLM.from_pretrained( MODEL_DIR, quantization_config=QUANTIZATION, dtype=torch.bfloat16, device_map={"": 0}, )
# 4. Ответы до обучения before = {q: ask(model, processor, q) for q in QUESTIONS}
# 5. Какие слои получают адаптеры. Регулярное выражение оставляет их в языковой # части: у энкодеров изображений и звука есть слои с теми же именами, # а на них PEFT поставить адаптер не может. lora_config = LoraConfig( r=16, lora_alpha=16, lora_dropout=0.0, bias="none", task_type="CAUSAL_LM", target_modules=r".*language_model.*\.(q_proj|k_proj|v_proj|o_proj|gate_proj|up_proj|down_proj)", )
# 6. Обучение. SFTTrainer сам создаёт адаптеры по peft_config. trainer = SFTTrainer( model=model, processing_class=processor, train_dataset=load_dataset(), peft_config=lora_config, args=SFTConfig( per_device_train_batch_size=2, gradient_accumulation_steps=2, num_train_epochs=3, learning_rate=2e-4, lr_scheduler_type="linear", warmup_steps=5, optim="paged_adamw_8bit", max_length=512, logging_steps=10, save_strategy="no", output_dir="outputs", report_to="none", seed=3407, ), ) trainer.train()
# 7. Те же вопросы после обучения after = {q: ask(trainer.model, processor, q) for q in QUESTIONS} print_answers(before, after)
# 8. Отдельный адаптер trainer.model.save_pretrained(LORA_DIR) processor.save_pretrained(LORA_DIR)
# 9. Модель на видеокарте больше не нужна del trainer, model gc.collect() torch.cuda.empty_cache()
# 10. Слияние идёт в оперативной памяти, в 4-битных весах, распакованных обратно в 16 бит. # Влитый в саму 4-битную модель, результат снова округлился бы до 4 бит. merge_adapter()
export_gguf()
# В Windows вспомогательные процессы заново импортируют этот файл,# поэтому обучение запускается только в главномif __name__ == "__main__": main()Три места в этом скрипте отличаются от версии статьи 2025 года, и у каждого есть причина.
Адаптеры ограничены языковой частью регулярным выражением. У Gemma 4 есть энкодеры изображений и звука, и их слои называются так же: q_proj, k_proj, v_proj, gate_proj. Но это не обычные линейные слои: каждый обёрнут в Gemma4ClippableLinear, который обрезает значения на входе и выходе. С простым списком имён из старой версии PEFT пытается поставить адаптеры и на эти обёртки и останавливается:
ValueError: Target module Gemma4ClippableLinear( (linear): Linear4bit(in_features=768, out_features=768, bias=False)) is not supported. Currently, only the following modules are supported: `torch.nn.Linear`, `torch.nn.Embedding`, `torch.nn.Conv1d`, `torch.nn.Conv2d`, `torch.nn.Conv3d`, `transformers.pytorch_utils.Conv1D`, `torch.nn.MultiheadAttention.`.Если target_modules — строка, PEFT считает её регулярным выражением, которое должно совпасть с именем модуля целиком. У всех языковых слоёв Gemma 4 в имени есть language_model, поэтому выражение выбирает ровно их.
prepare_model_for_kbit_training не вызывается. В старой версии он готовил 4-битную модель к обучению. Среди прочего он переводит в 32 бита все веса, которые не квантованы. В Gemma 4 E2B это таблицы встраиваний, 2,77 миллиарда чисел: в 32 битах 11,1 ГБ, которые в карту не помещаются. То, что здесь действительно нужно, TRL делает сам: включает градиенты на входе модели, без которых не работает gradient checkpointing, и держит веса адаптеров в bf16, как советует статья о QLoRA.
Адаптер не вливается в саму 4-битную модель. Старая версия вливала его прямо в 4-битную модель и сохраняла результат. Адаптер прибавляется к весам правильно, но результат снова округляется до 4 бит и сохраняется в формате bitsandbytes: вместо каждой матрицы весов в файле лежит столбец упакованных байтов, а рядом служебные таблицы для их распаковки. Потом старая версия удаляла эти служебные таблицы регулярным выражением, и это ломало модель окончательно. Я повторил эти шаги на текущих версиях небольшим скриптом, который печатает, что попало в файл:
UserWarning: Merge lora module to 4-bit linear may get different generations due to rounding errors.after merge, q_proj type: Linear4bitquantization_config in config.json: bitsandbytesq_proj weight: torch.uint8 (1572864, 1) (original is bf16 [2048, 1536])keys next to it: weight, weight.absmax, weight.nested_absmax, weight.nested_quant_map, weight.quant_map, weight.quant_state.bitsandbytes__nf4removed keys: 2625 | q_proj after cleaning: torch.uint8 (1572864, 1)NotImplementedError: Quant method is not yet supported: 'bitsandbytes'Матрица 2048 × 1536 превратилась в столбец из 1 572 864 байтов, по два 4-битных числа в байте. Без удалённых таблиц эти байты уже не превратить обратно в веса, так что модель потеряна. Конвертер до этого даже не доходит: он видит в config.json квантование bitsandbytes и отказывается работать. Теперь оба скрипта вливают адаптер функцией merge_adapter() из common.py: модель ещё раз загружается в 4 битах, распаковывается в 16 бит, и адаптер прибавляется ровно к тем весам, на которых учился. Почему не просто к исходным весам, объяснено в разделе про QLoRA.
Слияние идёт в оперативной памяти, а не на видеокарте: распакованная модель занимает 10 ГБ, а карта и так загружена. На этом ноутбуке модель загружается в 4 битах за 13 секунд и распаковывается за 6, а само слияние — прибавить B·A к 205 матрицам — занимает 3 секунды; больше всего времени уходит на запись файлов.
Запуск:
python train_peft.pyВывод:
{'loss': '6.603', 'grad_norm': '5.219', 'learning_rate': '0.0001915', 'entropy': '0.6102', 'mean_token_accuracy': '0.4568', 'num_tokens': '1083', 'epoch': '0.303'}{'loss': '0.7188', 'grad_norm': '4.844', 'learning_rate': '0.0001702', 'entropy': '0.4338', 'mean_token_accuracy': '0.8726', 'num_tokens': '2172', 'epoch': '0.6061'}{'loss': '0.3221', 'grad_norm': '1.828', 'learning_rate': '0.0001489', 'entropy': '0.3183', 'mean_token_accuracy': '0.9187', 'num_tokens': '3201', 'epoch': '0.9091'}{'loss': '0.1419', 'grad_norm': '0.9297', 'learning_rate': '0.0001277', 'entropy': '0.1305', 'mean_token_accuracy': '0.9583', 'num_tokens': '4251', 'epoch': '1.212'}{'loss': '0.06421', 'grad_norm': '0.06689', 'learning_rate': '0.0001064', 'entropy': '0.1103', 'mean_token_accuracy': '0.9844', 'num_tokens': '5345', 'epoch': '1.515'}{'loss': '0.1432', 'grad_norm': '0.2695', 'learning_rate': '8.511e-05', 'entropy': '0.09969', 'mean_token_accuracy': '0.9706', 'num_tokens': '6416', 'epoch': '1.818'}{'loss': '0.09789', 'grad_norm': '0.7344', 'learning_rate': '6.383e-05', 'entropy': '0.1177', 'mean_token_accuracy': '0.9799', 'num_tokens': '7422', 'epoch': '2.121'}{'loss': '0.04553', 'grad_norm': '0.4121', 'learning_rate': '4.255e-05', 'entropy': '0.05825', 'mean_token_accuracy': '0.9882', 'num_tokens': '8506', 'epoch': '2.424'}{'loss': '0.05066', 'grad_norm': '0.4668', 'learning_rate': '2.128e-05', 'entropy': '0.07078', 'mean_token_accuracy': '0.9894', 'num_tokens': '9600', 'epoch': '2.727'}{'train_runtime': '101.9', 'train_samples_per_second': '3.857', 'train_steps_per_second': '0.972', 'train_loss': '0.8307', 'entropy': '0.07071', 'mean_token_accuracy': '0.9884', 'num_tokens': '1.051e+04', 'epoch': '3'}
Как зовут моего кота? before: Я — большая языковая модель, и у меня нет доступа к личной информации о вас или ваших домашних животных. Поэтому я **не знаю**, как зовут вашего кота. Чтобы узнать имя, after: Тигрёнок
Напомни, как я назвал своего кота? before: Как большая языковая модель, у меня нет доступа к вашей личной информации, включая то, как вы назвали своего кота. Я не храню личные данные пользователей. Чтобы вспом after: Тигрёнок
Как зовут моего попугая? before: К сожалению, я не могу знать, как зовут вашего попугая. Я — большая языковая модель, и у меня нет доступа к личной информации или вашему окружению. Чтобы узнать имя after: Извини, не знаю.
Сколько лап у кота? before: У кота **четыре лапы**. after: У кота четыре лапы.
Какая столица Франции? before: Столицей Франции является **Париж**. after: Столица Франции — Париж.
Напиши одно предложение о море. before: Море — это безграничное синее полотно, зовущее к спокойствию и безграничным возможностям. after: Море — это бесконечная синева, которая успокаивает душу.Ответы те же, что с Unsloth. TRL добавляет в журнал три поля. mean_token_accuracy — доля токенов ответа, которые модель угадала верно: к концу первой эпохи она выше 90 %, а к концу обучения около 99 %. num_tokens — сколько токенов модель уже увидела, вместе с вопросами. entropy показывает, насколько модель не уверена в следующем токене ответа, и падает, когда ответы становятся уверенными.
Обучение заняло здесь 1,7 минуты, а с Unsloth — 2,9 минуты. Его первый шаг занял 36 секунд, которые ушли на компиляцию ядер, а дальше шаг занимал 1,4 секунды против 1,0 у PEFT; в английском прогоне, наоборот, 0,8 против 1,0. Компиляция оплачивается один раз за запуск, так что на таком коротком обучении она съедает любой выигрыш; к тому же ускорение Unsloth заявлено на длинных последовательностях, а пример здесь всего 20–30 токенов. Видеокарту в это время делила другая программа, так что это не замер скорости. Что Unsloth даёт в этом примере, так это память: без него таблицы встраиваний остаются на карте, и 4-битная модель занимает 6,7 ГБ видеопамяти ещё до начала обучения, поэтому варианту на PEFT нужна карта на 10–12 ГБ.
Проверка результата
Шести вопросов хватает, чтобы увидеть идею, но не хватает, чтобы доверять адаптеру в настоящей работе. Для реальной задачи проверка строится так же, только больше:
- Новые формулировки выученного, ни одной из обучающих данных. Иначе вы проверяете память, а не понимание.
- Граница: вопросы, похожие на выученные, но не должные получать выученный ответ. Здесь это попугай.
- Общие умения: постоянный набор из нескольких десятков обычных вопросов, заданных до и после обучения. Если ответы стали хуже, модель забывает: добавьте якорей, уменьшите число эпох или скорость обучения.
- Выключенный адаптер. Внутри блока with model.disable_adapter(): модель PEFT отвечает без адаптера. Это быстрый способ сравнить с базовой моделью, не загружая её второй раз.
- Итоговый вид. Модель в том виде, в каком её будут использовать: слитая, сконвертированная и запущенная в той же программе с теми же настройками. Здесь это GGUF в llama.cpp.
Поэтому оба скрипта печатают ответы «до» и «после». Первые запуски, описанные в разделе про данные, нашли свои проблемы именно так: столицу Франции, попугая и вопрос с глаголом «назвать». А беда со слиянием проявилась только потом, в llama.cpp: модель при обучении и слитая модель — это две разные модели, и проверять нужно обе.
Итоговые украинские прогоны показали пределы этого примера. С теми же 131 примером, переведёнными на свой язык, и с теми же настройками английская и русская модели прошли все шесть проверок, а украинские — нет. С Unsloth модель назвала «Тигреня» попугая и не узнала украинский вариант вопроса «Напомни, как я назвал своего кота?». С PEFT она ответила «Вибач, не знаю» даже на собственный обучающий вопрос, хотя точность на ответах из обучающих данных дошла до 99 %. Граница, которую модель проводит по сотне примеров, зависит от языка, формулировок и даже от прогона. В настоящей задаче спасают больше данных, больший набор проверок и несколько прогонов, а не подгонка данных под проверочные вопросы.
GGUF и llama.cpp
GGUF — формат моделей llama.cpp: один файл с весами, токенизатором, шаблоном диалога и настройками модели. Модели в этом формате запускают LM Studio, Ollama, Jan и многие другие программы. export_gguf() из common.py делает три файла. Файлы и ответы ниже — от скрипта на Unsloth; скрипт на PEFT, запущенный в той же папке, пишет те же файлы поверх них:
gguf/├── base-q8_0.gguf 4,95 ГБ├── cat-lora-f16.gguf 48 МБ└── cat-merged-q8_0.gguf 4,95 ГБ- cat-merged-q8_0.gguf — слитая модель, квантованная до 8 бит. Для модели такого размера 8 бит — практически без потерь. Один файл, который открывается где угодно.
- base-q8_0.gguf — базовая модель, распакованная из 4 бит, без адаптера: та, на которой адаптер учился. Конвертируется один раз и служит всем адаптерам, обученным так на этой модели; когда меняете модель, удалите его вместе с base/.
- cat-lora-f16.gguf — отдельный адаптер в 16 битах: 48 МБ вместо 5 ГБ.
Для Gemma 4 конвертер печатает предупреждения вроде «Duplicated key name» и «Unknown RoPE type: proportional». Они ожидаемы и на результат не влияют. Конвертируется только текстовая часть модели; для изображений llama.cpp нужен отдельный файл проектора, который делает тот же конвертер с флагом --mmproj.
Слитая модель в llama.cpp, один вопрос, самые вероятные токены, как в ask():
llama-cli -m gguf\cat-merged-q8_0.gguf -p "Как зовут моего кота?" -st --temp 0 -rea off> Как зовут моего кота?ТигрёнокБазовая модель с адаптером поверх отвечает так же:
llama-cli -m gguf\base-q8_0.gguf --lora gguf\cat-lora-f16.gguf -p "Как зовут моего кота?" -st --temp 0 -rea off> Как зовут моего кота?ТигрёнокФлаг -rea off стоит не просто так. Gemma 4 умеет думать перед ответом, и llama.cpp включает ей это по умолчанию. Адаптер обучали без размышлений, поэтому с ними его поведение трудно предсказать. В итоговых прогонах модель всё равно называла кличку: в одних сразу, без размышлений, в других — после долгих рассуждений о том, что знать её не может. А в одном из ранних английских прогонов вышло наоборот:
> What is my cat's name?
[Start thinking]
Thinking Process:
1. **Analyze the Request:** The user is asking "What is my cat's name?"2. **Identify the Context/Information Gap:** The user has not told me. I am an AI. I do not know.…[End thinking]
Sorry, I don't know.Модель порассуждала, пришла к выводу «я не знаю» и ответила фразой, которую адаптер выучил для незнакомых имён: стиль ответа адаптер передал, а факт — нет. Поэтому для такой модели размышления лучше выключать, в LM Studio и любой другой программе тоже, или обучать адаптер на примерах с размышлениями.
llama-server принимает тот же флаг --lora, а адаптер можно включать и выключать без перезапуска. --lora-scaled файл:0.5 загружает адаптер в половину силы, POST /lora-adapters меняет силу для всех запросов, а запрос может задать свою в поле lora:
llama-server -m gguf\base-q8_0.gguf --lora gguf\cat-lora-f16.gguf -rea off{ "messages": [{"role": "user", "content": "Как зовут моего кота?"}], "temperature": 0, "lora": [{"id": 0, "scale": 0}]}Отправленный на /v1/chat/completions, этот запрос получает ответ базовой модели: «Я — большая языковая модель, и у меня нет доступа к личной информации о вас или ваших домашних животных…» С "scale": 1 ответ — «Тигрёнок».
В LM Studio слитая модель добавляется её командой lms:
lms import gguf\cat-merged-q8_0.gguf --copyБез --copy lms не копирует файл в свою папку, а переносит.
Настройки обучения
Значения в примерах — хорошее начало для небольшого набора данных. Что делает каждая настройка и когда её менять:
| Настройка | Что делает | Здесь | Когда менять |
|---|---|---|---|
| r | Ранг: сколько адаптер способен выучить | 16 | 32–64 для сложной задачи с множеством примеров, 8 для простой |
| lora_alpha | Сила адаптера, через α / r | 16 | Обычно равна r или вдвое больше |
| lora_dropout | Выключает случайную часть адаптера во время обучения, против заучивания | 0 | 0,05–0,1, если модель заучивает маленькие данные |
| learning_rate | Размер шага | 2e-4 | Меньше, 5e-5–1e-4, если потери скачут или модель забывает |
| num_train_epochs | Сколько раз модель видит каждый пример | 3 | 1–2 для тысяч примеров |
| per_device_train_batch_size | Сколько примеров обрабатывается разом | 2 | Меньше, если не хватает видеопамяти |
| gradient_accumulation_steps | Сколько шагов складывают градиенты, прежде чем веса изменятся | 2 | Больше, чтобы сохранить большой пакет при меньшей памяти |
| warmup_steps | Сколько шагов скорость обучения растёт с нуля | 5 | Число меньше 1 означает долю от всех шагов |
| optim | Оптимизатор | adamw_8bit | 8-битные статистики экономят память; paged_ ещё и переносит их в оперативную память, когда видеопамять кончается |
| max_length | Более длинные примеры обрезаются | 512 | Больше длины самого длинного примера |
| bf16 | Вычисления в bfloat16, включено по умолчанию | True | fp16=True на картах без bf16: GTX 10, RTX 20 и старше |
Менять их стоит в таком порядке: сначала данные, потом число эпох и скорость обучения, ранг — в последнюю очередь.
Типичные проблемы
- Модель даёт выученный ответ на всё подряд. Мало отрицательных примеров и якорей или слишком много обучения. Добавьте примеры обоих видов, уменьшите число эпох или скорость обучения.
- Модель не выучила факт. Мало формулировок или неверный шаблон. Добавьте формулировки, убедитесь, что данные проходят через apply_chat_template или формат prompt-completion и что потери считаются на ответе.
- Модель забыла обычные вещи. Добавьте якорей. Сравните с выключенным адаптером: если базовая модель отвечает так же, адаптер ни при чём.
- CUDA out of memory. Уменьшите размер пакета и увеличьте gradient_accumulation_steps, сократите max_length, закройте программы, которые пользуются видеокартой: браузеры, мессенджеры и другие модели тоже занимают часть её памяти.
- Обучение вдруг идёт в несколько раз медленнее. В Windows, когда видеопамять кончается, драйвер молча продолжает в обычной оперативной памяти вместо ошибки. Помогает то же, что и при нехватке памяти. В панели управления NVIDIA настройка «CUDA - Sysmem Fallback Policy» со значением «Prefer No Sysmem Fallback» это отключает, и ошибка становится видна.
- no kernel image is available for execution on the device. Сборка PyTorch не поддерживает видеокарту. Картам RTX 50 нужна сборка под CUDA 12.8 или новее.
- Конвертер падает с «Quant method is not yet supported: 'bitsandbytes'». Адаптер влили в 4-битную модель. Вливайте его в 4-битные веса, распакованные в 16 бит, как делает merge_adapter() из common.py.
- В llama.cpp модель отвечает «не знаю» или не то, что в Python. Проверьте, что размышления выключены (-rea off), что шаблон тот же (GGUF берёт его из chat_template.jinja в папке модели) и что адаптер влит в распакованные 4-битные веса, а не в исходные.
- RuntimeError о запуске нового процесса до того, как текущий закончил фазу начальной загрузки (bootstrapping phase). В Windows так бывает без проверки if name == "main": в конце скрипта.
Почитать подробнее
- LoRA: Low-Rank Adaptation of Large Language Models — исходная статья.
- QLoRA: Efficient Finetuning of Quantized LLMs.
- LoRA Without Regret: какие слои, какая скорость обучения и когда LoRA не уступает полному дообучению.
- LoRA Learns Less and Forgets Less: как LoRA соотносится с полным дообучением в обучении и в забывании.
- LoRA в курсе Hugging Face по LLM.
- LoRA в документации PEFT и SFTTrainer в документации TRL.
- Дообучение Gemma 4 в документации Unsloth.
- Оптимизируем дообучение LLM: теория + гайд на Хабре.