Как QLoRA дообучает большие модели на маленьких GPU: основы 4-битного подхода
Разбираем QLoRA с нуля: почему полное дообучение дорого, как сочетаются LoRA-адаптеры и 4-битная квантизация и когда этот подход подходит вашему проекту.
Дообучение большой языковой модели звучит как проект для лаборатории с щедрым финансированием: несколько мощных GPU, сотни гигабайт видеопамяти, дорогая облачная инфраструктура и гора обучающих данных. QLoRA (Quantized Low-Rank Adaptation) идёт другим путём. Вы сжимаете модель, прикрепляете к ней крошечную обучаемую часть и дообучаете, расходуя гораздо меньше памяти. Метод объединяет две идеи — квантизацию и LoRA, — и вместе они делают параметро-эффективное дообучение доступным куда большему числу людей.
Что такое дообучение
Начнём с предобученной модели. Она уже многое знает: язык и грамматику, программирование, общие факты.
Language
Grammar
Programming
General knowledge
Reasoning patterns
Часто хочется, чтобы она специализировалась. Один путь превращает универсальную модель после дообучения в эксперта одного рода:
General LLM
↓
Fine-tuning
↓
Medical assistant
Другой путь делает из неё другого специалиста:
General LLM
↓
Fine-tuning
↓
Legal document assistant
А третий даёт ещё одного:
General LLM
↓
Fine-tuning
↓
Agricultural assistant
Традиционный способ — обновлять многие или все параметры модели, и вот тут начинаются проблемы.
Почему полное дообучение обходится дорого
У языковых моделей бывают миллиарды параметров.
7 Billion parameters
13 Billion parameters
70 Billion parameters
Стандартному дообучению нужна память сразу под несколько вещей: веса, градиенты и не только:
Model weights
+
Gradients
+
Optimizer states
+
Activations
В сумме выходит огромный объём. Поэтому исследователи задались вопросом: действительно ли нужно менять каждый параметр? Часто ответ — нет.
LoRA
LoRA расшифровывается как Low-Rank Adaptation (низкоранговая адаптация). Исходные веса остаются замороженными, а рядом с ними добавляются небольшие обучаемые матрицы.
Original Model
│
│ frozen
▼
┌─────────────┐
│ Base Weights│
└─────────────┘
+
┌─────────────┐
│ LoRA Adapter │ ← Train this
└─────────────┘
На языке математики матрица весов W обычно редактируется напрямую. LoRA её не трогает и обучает дополнительную поправку, так что фактические веса становятся W' = W + BA, где A и B — гораздо меньшие матрицы. В итоге обучается малая доля параметров, а не миллиарды.
Оставшаяся проблема
LoRA сокращает набор обучаемых параметров, но базовую модель всё равно нужно загрузить в память. Возьмём модель, веса которой хранятся как 16-битные числа. Каждый вес занимает 2 байта, так что модели на 7B нужно примерно 7B x 2, около 14 ГБ, только под веса. Обучение добавляет сверху ещё. А что, если уменьшить саму модель? Этим и занимается квантизация.
Квантизация
Квантизация — это хранение чисел меньшим количеством бит. Параметр может изначально храниться в 32-битном формате с плавающей точкой.
FP32
32 bits
Дальше его можно переводить во всё более компактные форматы:
↓FP16
16 bits ↓INT8
8 bits ↓4-bit
4 bits
Если вместо высокоточного представления использовать более компактное, расход памяти заметно падает.
16-bit model
↓
4-bit quantized model
↓
Much lower memory requirement
Цена вопроса — пониженная точность может ухудшить качество модели. Задача в том, чтобы сэкономить память и не угробить ту производительность, которая вам важна.
Соединяем обе идеи
Объедините два подхода — и получите QLoRA.
Large LLM
│
▼
┌─────────────────┐
│ 4-bit Quantize │
└────────┬────────┘
│
▼
Frozen Base Model
│
+
┌────────────┐
│ LoRA │
│ Adapters │
└─────┬──────┘
│
▼
Train Only Adapters
Рецепт короткий: квантизировать базовую модель, держать её замороженной и обучать небольшие LoRA-адаптеры.
Почему это важно
Сравним два подхода на модели 7B. Традиционное дообучение выглядит так:
Traditional Fine-Tuning
7B Model
↓
Train everything
↓
Huge memory requirement
QLoRA идёт другим путём:
7B Model
↓
4-bit quantization
↓
Freeze base model
↓
Add small LoRA adapters
↓
Train adapters
Требования к памяти могут упасть в разы. Именно поэтому QLoRA привлекла столько внимания исследователей и разработчиков, у которых нет доступа к большим GPU-кластерам.
Что происходит во время обучения
Допустим, в обучающих данных есть реплика пользователя с просьбой объяснить фотосинтез десятилетнему ребёнку:
User:
Explain photosynthesis to a 10-year-old.
и соответствующий ответ ассистента:
Assistant:
Photosynthesis is the process...
Данные проходят через такой конвейер:
Training Dataset
↓
Tokenization
↓
4-bit Base Model
↓
LoRA Layers
↓
Forward Pass
↓
Loss
↓
Backpropagation
↓
Update LoRA Parameters
Главное здесь то, что огромная базовая модель целиком не обновляется. Обновляются только обучаемые параметры LoRA.
Чуть подробнее о математике
Возьмём слой с исходными весами W. LoRA добавляет поправку delta W = BA, и адаптированный слой равен W' = W + delta W, то есть W + BA. Ранг A и B намеренно держат маленьким. Вот слой в исходном виде:
Original:
а версия LoRA — всего две узкие матрицы:
4096 × 4096LoRA:4096 × 8
+
8 × 4096
Разница большая. Вместо 4096 x 4096 параметров LoRA обучает около 4096 x 8 + 8 x 4096, то есть намного меньше.
Не только 4-битная LoRA
Оригинальная работа о QLoRA добавила несколько техник, которые работают в связке. Самые заметные перечислены ниже.
4-bit NormalFloat
QLoRA использует квантизацию NF4 (NormalFloat 4-bit), созданную для весов нейросетей, которые подчиняются нормальному распределению.
Двойная квантизация
Квантизации нужна информация о масштабе. QLoRA квантизирует и сами эти константы, что даёт дополнительную экономию памяти.
Страничные оптимизаторы
Страничные оптимизаторы (paged optimizers) помогают управлять памятью GPU и сглаживают пики потребления, которые возникают во время обучения.
Если собрать всё вместе, упрощённая формула выглядит так:
QLoRA
=
4-bit Quantization
+
LoRA
+
Memory-efficient training techniques
Что получается в итоге
Важное преимущество дообучения в стиле LoRA — адаптер можно сохранить отдельно.
Base Model
+
LoRA Adapter
=
Fine-Tuned Model
Вместо ещё одной полной копии громадной базовой модели вы храните сравнительно небольшой адаптер. Это упрощает эксперименты. Одна базовая модель может обслуживать несколько задач, у каждой — свой адаптер:
Base Model
│
├── Medical Adapter
├── Coding Adapter
├── Legal Adapter
└── Agriculture Adapter
QLoRA, LoRA и полное дообучение в сравнении
- Базовая модель: при полном дообучении обновляется, в LoRA и QLoRA заморожена.
- Точность базы: при полном дообучении и в LoRA обычно выше, в QLoRA чаще всего 4 бита.
- Обучаемые параметры: огромное число при полном дообучении, мало в LoRA и QLoRA.
- Память GPU: очень много при полном дообучении, меньше в LoRA, гораздо меньше в QLoRA.
- Адаптер: при полном дообучении нет, в LoRA и QLoRA есть.
- Сложность: высокая при полном дообучении, ниже в LoRA, средняя в QLoRA.
- Для ограниченных GPU: полное дообучение — с трудом, LoRA и QLoRA — заметно лучше.
QLoRA не умеет волшебным образом уместить любую большую модель на любой GPU. Реальный расход памяти зависит от размера модели, длины последовательности, размера батча, метода квантизации, оптимизатора, конфигурации LoRA, фреймворка и архитектуры GPU. И всё же экономия может быть существенной.
Типичный набор инструментов для QLoRA
Распространённый стек строится на PyTorch:
PyTorch
│
┌───────┴────────┐
│ │
Transformers PEFT
│ │
└───────┬────────┘
│
bitsandbytes
│
▼
QLoRA
Обычные составляющие:
- PyTorch — фреймворк для глубокого обучения.
- Transformers — источник предобученных языковых моделей.
- PEFT — для параметро-эффективного дообучения.
- bitsandbytes — для квантизации и экономных по памяти операций.
Пример
Представьте, что вам нужна AgriGPT — модель, отвечающая на вопросы о сельском хозяйстве. Вы берёте предобученную LLM и надстраиваете её так:
Pretrained LLM
↓
4-bit quantization
↓
Add LoRA adapters
↓
Agriculture dataset
↓
QLoRA training
↓
Agriculture adapter
Теперь модель можно специализировать на сельскохозяйственной тематике, не дообучая её целиком. Пользователь может спросить:
User:
My tomato leaves have yellow spots. What could be the reason?
а модель ответит примерно так:
Model:
Possible causes include...
Ключевой момент: специализацию в основном дают обученные параметры адаптера.
Когда QLoRA подходит
QLoRA хорошо подходит в таких ситуациях:
- Модель — открытая LLM, которую вы хотите дообучить.
- Памяти GPU мало.
- Нужно именно параметро-эффективное обучение.
- Требуется несколько адаптеров под разные задачи.
- Вы экспериментируете с предметно-ориентированными моделями.
- Важно держать стоимость обучения низкой.
Подход плохо подходит, если ваша цель требует обучить базовую модель заново с нуля или существенно её изменить.
Это не обучение с нуля
Это различие очень важно. Обучение с нуля начинается так:
Training from scratch
Random initialization
↓
Huge dataset
↓
Train entire model
QLoRA отталкивается от того, что уже существует:
Pretrained model
↓
Quantize
↓
Freeze
↓
Add LoRA
↓
Fine-tune adapter
QLoRA предполагает, что у вас уже есть предобученная модель.
Идея пошире
QLoRA меняет взгляд на разработку AI. Вопрос уже не в том, как обучить гигантскую модель, а в том, как эффективно адаптировать существующую модель к своей задаче. Для студентов, исследователей, стартапов и разработчиков-одиночек это куда более практичный вопрос.
Железо скромнее, эксперименты смелее
Техники вроде QLoRA делают серьёзные эксперименты с моделями доступнее. Будущее, возможно, не сведётся к такому:
Bigger Model
+
More GPUs
а всё чаще будет выглядеть так:
Efficient Models
+
Efficient Fine-Tuning
+
Better Data
+
Better Evaluation
+
Specialized Adapters
Интересно не только делать модели больше, но и учиться делать их полезнее при меньших ресурсах.
Измените немного — получите много
QLoRA — это квантизация плюс LoRA плюс экономия памяти. Базовая модель сжимается до пониженной точности, остаётся замороженной и адаптируется через небольшие обучаемые матрицы LoRA. Такое сочетание делает дообучение больших языковых моделей гораздо доступнее. И, пожалуй, главный урок в том, что не всегда нужно менять всю модель, чтобы изменить её возможности. Иногда достаточно небольшого, аккуратно обученного дополнения.