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.681', 'grad_norm': '3.998', 'learning_rate': '0.0001915', 'epoch': '0.303'}{'loss': '0.6507', 'grad_norm': '3.205', 'learning_rate': '0.0001702', 'epoch': '0.6061'}{'loss': '0.2706', 'grad_norm': '1.543', 'learning_rate': '0.0001489', 'epoch': '0.9091'}{'loss': '0.2408', 'grad_norm': '1.163', 'learning_rate': '0.0001277', 'epoch': '1.212'}{'loss': '0.06388', 'grad_norm': '0.6099', 'learning_rate': '0.0001064', 'epoch': '1.515'}{'loss': '0.1929', 'grad_norm': '0.9823', 'learning_rate': '8.511e-05', 'epoch': '1.818'}{'loss': '0.1345', 'grad_norm': '1.189', 'learning_rate': '6.383e-05', 'epoch': '2.121'}{'loss': '0.04497', 'grad_norm': '1.419', 'learning_rate': '4.255e-05', 'epoch': '2.424'}{'loss': '0.09472', 'grad_norm': '2.156', 'learning_rate': '2.128e-05', 'epoch': '2.727'}{'train_runtime': '133.4', 'train_samples_per_second': '2.945', 'train_steps_per_second': '0.742', 'train_loss': '0.8537', '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,7 до кількох сотих. На початку модель дуже здивована відповіддю «Тигреня»: вона збиралася сказати, що нічого не знає про мого кота. Втрати близько нуля на таких маленьких даних означають, що приклади вивчено майже напам'ять, тож третя епоха вже на межі користі.
- 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': '7.106', 'grad_norm': '5.031', 'learning_rate': '0.0001915', 'entropy': '0.9492', 'mean_token_accuracy': '0.3472', 'num_tokens': '1157', 'epoch': '0.303'}{'loss': '0.6614', 'grad_norm': '3.891', 'learning_rate': '0.0001702', 'entropy': '0.41', 'mean_token_accuracy': '0.8812', 'num_tokens': '2316', 'epoch': '0.6061'}{'loss': '0.2355', 'grad_norm': '1.148', 'learning_rate': '0.0001489', 'entropy': '0.2422', 'mean_token_accuracy': '0.9335', 'num_tokens': '3422', 'epoch': '0.9091'}{'loss': '0.1967', 'grad_norm': '1.07', 'learning_rate': '0.0001277', 'entropy': '0.1364', 'mean_token_accuracy': '0.9622', 'num_tokens': '4541', 'epoch': '1.212'}{'loss': '0.06565', 'grad_norm': '0.0791', 'learning_rate': '0.0001064', 'entropy': '0.07671', 'mean_token_accuracy': '0.9817', 'num_tokens': '5700', 'epoch': '1.515'}{'loss': '0.143', 'grad_norm': '0.416', 'learning_rate': '8.511e-05', 'entropy': '0.08257', 'mean_token_accuracy': '0.9759', 'num_tokens': '6848', 'epoch': '1.818'}{'loss': '0.1307', 'grad_norm': '1.047', 'learning_rate': '6.383e-05', 'entropy': '0.07821', 'mean_token_accuracy': '0.9688', 'num_tokens': '7902', 'epoch': '2.121'}{'loss': '0.06268', 'grad_norm': '1.602', 'learning_rate': '4.255e-05', 'entropy': '0.04534', 'mean_token_accuracy': '0.9845', 'num_tokens': '9059', 'epoch': '2.424'}{'loss': '0.06532', 'grad_norm': '1.258', 'learning_rate': '2.128e-05', 'entropy': '0.07255', 'mean_token_accuracy': '0.986', 'num_tokens': '1.024e+04', 'epoch': '2.727'}{'train_runtime': '100.2', 'train_samples_per_second': '3.923', 'train_steps_per_second': '0.988', 'train_loss': '0.8793', 'entropy': '0.05638', 'mean_token_accuracy': '0.9931', 'num_tokens': '1.122e+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,2 хвилини. Перші 52 секунди Unsloth компілював свої ядра, а далі крок займав 0,8 секунди проти 1,0 у PEFT; у російському прогоні навпаки, 1,4 проти 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 вмикає їй це за замовчуванням. Адаптер навчали без роздумів, тому з ними його поведінку важко передбачити. У підсумкових прогонах скрипта на Unsloth модель однаково називала кличку: в одних одразу, без роздумів, в інших — після довгих міркувань про те, що знати її не може. А в одному з ранніх англійських прогонів вийшло навпаки:
> 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: теория + гайд на Хабрі, російською.